Skip to main content

spodes_rs/classes/
ipv6_setup.rs

1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::NeighborDiscoverySetup;
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8/// Configuration structure used to build an [`Ipv6Setup`] object.
9#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct Ipv6SetupConfig {
11    /// Attribute 1: the object's logical name (OBIS code).
12    pub logical_name: ObisCode,
13    /// Attribute 2: reference to the data link layer setup object.
14    pub dl_reference: Vec<u8>,
15    /// Attribute 3: address configuration mode (enum).
16    pub address_config_mode: u8,
17    /// Attribute 4: array of unicast IPv6 addresses (octet-string, 16 octets).
18    pub unicast_ipv6_addresses: Vec<Vec<u8>>,
19    /// Attribute 5: array of multicast IPv6 addresses.
20    pub multicast_ipv6_addresses: Vec<Vec<u8>>,
21    /// Attribute 6: array of gateway IPv6 addresses.
22    pub gateway_ipv6_addresses: Vec<Vec<u8>>,
23    /// Attribute 7: primary DNS address (octet-string).
24    pub primary_dns_address: Vec<u8>,
25    /// Attribute 8: secondary DNS address (octet-string).
26    pub secondary_dns_address: Vec<u8>,
27    /// Attribute 9: traffic class (0..63).
28    pub traffic_class: u8,
29    /// Attribute 10: array of neighbor discovery setup structures.
30    pub neighbor_discovery_setup: Vec<NeighborDiscoverySetup>,
31}
32
33/// `IPv6 setup` interface class (class_id = 48, version = 0) per IEC 62056-6-2
34/// §4.9.3. Configures the IPv6 network layer.
35#[derive(Clone, Serialize, Deserialize, Debug)]
36pub struct Ipv6Setup {
37    logical_name: ObisCode,
38    dl_reference: Vec<u8>,
39    address_config_mode: u8,
40    unicast_ipv6_addresses: Vec<Vec<u8>>,
41    multicast_ipv6_addresses: Vec<Vec<u8>>,
42    gateway_ipv6_addresses: Vec<Vec<u8>>,
43    primary_dns_address: Vec<u8>,
44    secondary_dns_address: Vec<u8>,
45    traffic_class: u8,
46    neighbor_discovery_setup: Vec<NeighborDiscoverySetup>,
47}
48
49impl Ipv6Setup {
50    /// Builds a new [`Ipv6Setup`] from its configuration.
51    pub fn new(config: Ipv6SetupConfig) -> Self {
52        Ipv6Setup {
53            logical_name: config.logical_name,
54            dl_reference: config.dl_reference,
55            address_config_mode: config.address_config_mode,
56            unicast_ipv6_addresses: config.unicast_ipv6_addresses,
57            multicast_ipv6_addresses: config.multicast_ipv6_addresses,
58            gateway_ipv6_addresses: config.gateway_ipv6_addresses,
59            primary_dns_address: config.primary_dns_address,
60            secondary_dns_address: config.secondary_dns_address,
61            traffic_class: config.traffic_class,
62            neighbor_discovery_setup: config.neighbor_discovery_setup,
63        }
64    }
65
66    /// Method 1: `add_IPv6_address` — adds a unicast IPv6 address.
67    fn add_ipv6_address(&mut self, data: &CosemDataType) -> Result<CosemDataType, String> {
68        match data {
69            CosemDataType::OctetString(addr) => {
70                if !self.unicast_ipv6_addresses.contains(addr) {
71                    self.unicast_ipv6_addresses.push(addr.clone());
72                }
73                Ok(CosemDataType::Null)
74            }
75            _ => Err("add_IPv6_address expects an octet-string".to_string()),
76        }
77    }
78
79    /// Method 2: `remove_IPv6_address` — removes a unicast IPv6 address.
80    fn remove_ipv6_address(&mut self, data: &CosemDataType) -> Result<CosemDataType, String> {
81        let addr = match data {
82            CosemDataType::OctetString(v) => v.clone(),
83            _ => return Err("remove_IPv6_address expects an octet-string".to_string()),
84        };
85        let before = self.unicast_ipv6_addresses.len();
86        self.unicast_ipv6_addresses.retain(|a| *a != addr);
87        if self.unicast_ipv6_addresses.len() == before {
88            return Err("IPv6 address not found".to_string());
89        }
90        Ok(CosemDataType::Null)
91    }
92}
93
94impl InterfaceClass for Ipv6Setup {
95    fn class_id(&self) -> u16 {
96        48
97    }
98
99    fn version(&self) -> u8 {
100        0
101    }
102
103    fn logical_name(&self) -> &ObisCode {
104        &self.logical_name
105    }
106
107    fn attributes(&self) -> Vec<(u8, CosemDataType)> {
108        vec![
109            (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
110            (2, CosemDataType::OctetString(self.dl_reference.clone())),
111            (3, CosemDataType::Enum(self.address_config_mode)),
112            (
113                4,
114                CosemDataType::Array(
115                    self.unicast_ipv6_addresses.iter().cloned().map(CosemDataType::OctetString).collect(),
116                ),
117            ),
118            (
119                5,
120                CosemDataType::Array(
121                    self.multicast_ipv6_addresses.iter().cloned().map(CosemDataType::OctetString).collect(),
122                ),
123            ),
124            (
125                6,
126                CosemDataType::Array(
127                    self.gateway_ipv6_addresses.iter().cloned().map(CosemDataType::OctetString).collect(),
128                ),
129            ),
130            (7, CosemDataType::OctetString(self.primary_dns_address.clone())),
131            (8, CosemDataType::OctetString(self.secondary_dns_address.clone())),
132            (9, CosemDataType::Unsigned(self.traffic_class)),
133            (
134                10,
135                CosemDataType::Array(self.neighbor_discovery_setup.iter().cloned().map(CosemDataType::from).collect()),
136            ),
137        ]
138    }
139
140    fn methods(&self) -> Vec<(u8, String)> {
141        vec![(1, "add_IPv6_address".to_string()), (2, "remove_IPv6_address".to_string())]
142    }
143
144    fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
145        let mut seq_buf = Vec::new();
146        CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
147        for (_, attr) in self.attributes() {
148            attr.serialize_ber(&mut seq_buf)?;
149        }
150        buf.push(0x02); // structure [2]
151        write_length(1 + self.attributes().len(), buf); // length = element count
152        buf.extend_from_slice(&seq_buf);
153        Ok(())
154    }
155
156    fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
157        let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
158        if !rest.is_empty() {
159            return Err(BerError::InvalidTag);
160        }
161        let CosemDataType::Structure(seq) = tlv else {
162            return Err(BerError::InvalidTag);
163        };
164        // class_id + 10 attributes.
165        if seq.len() != 11 {
166            return Err(BerError::InvalidLength);
167        }
168        if let CosemDataType::LongUnsigned(class_id) = seq[0] {
169            if class_id != self.class_id() {
170                return Err(BerError::InvalidValue);
171            }
172        } else {
173            return Err(BerError::InvalidTag);
174        }
175        if let CosemDataType::OctetString(obis) = &seq[1] {
176            if obis.len() == 6 {
177                self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
178            } else {
179                return Err(BerError::InvalidLength);
180            }
181        } else {
182            return Err(BerError::InvalidTag);
183        }
184        self.dl_reference = take_octet_string(&seq[2])?;
185        self.address_config_mode = match seq[3] {
186            CosemDataType::Enum(v) => v,
187            _ => return Err(BerError::InvalidTag),
188        };
189        self.unicast_ipv6_addresses = take_octet_string_array(&seq[4])?;
190        self.multicast_ipv6_addresses = take_octet_string_array(&seq[5])?;
191        self.gateway_ipv6_addresses = take_octet_string_array(&seq[6])?;
192        self.primary_dns_address = take_octet_string(&seq[7])?;
193        self.secondary_dns_address = take_octet_string(&seq[8])?;
194        self.traffic_class = match seq[9] {
195            CosemDataType::Unsigned(v) => v,
196            _ => return Err(BerError::InvalidTag),
197        };
198        self.neighbor_discovery_setup = take_nds_array(&seq[10])?;
199        Ok(())
200    }
201
202    fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
203        match method_id {
204            1 => self.add_ipv6_address(&params.ok_or("Missing method parameter")?),
205            2 => self.remove_ipv6_address(&params.ok_or("Missing method parameter")?),
206            _ => Err(format!("Method {method_id} not supported for IPv6 setup")),
207        }
208    }
209
210    fn as_any(&self) -> &dyn Any {
211        self
212    }
213}
214
215fn take_octet_string(value: &CosemDataType) -> Result<Vec<u8>, BerError> {
216    match value {
217        CosemDataType::OctetString(bytes) => Ok(bytes.clone()),
218        _ => Err(BerError::InvalidTag),
219    }
220}
221
222fn take_octet_string_array(value: &CosemDataType) -> Result<Vec<Vec<u8>>, BerError> {
223    match value {
224        CosemDataType::Array(list) => list
225            .iter()
226            .map(|item| match item {
227                CosemDataType::OctetString(v) => Ok(v.clone()),
228                _ => Err(BerError::InvalidTag),
229            })
230            .collect(),
231        _ => Err(BerError::InvalidTag),
232    }
233}
234
235fn take_nds_array(value: &CosemDataType) -> Result<Vec<NeighborDiscoverySetup>, BerError> {
236    match value {
237        CosemDataType::Array(list) => {
238            list.iter().map(|item| NeighborDiscoverySetup::try_from(item).map_err(|_| BerError::InvalidValue)).collect()
239        }
240        _ => Err(BerError::InvalidTag),
241    }
242}
243
244/// Writes a BER length octet (short or long form).
245#[allow(clippy::cast_possible_truncation)] // length < 128 and num_octets in 1..=8 always fit u8
246fn write_length(length: usize, buf: &mut Vec<u8>) {
247    if length < 128 {
248        buf.push(length as u8);
249    } else {
250        let bytes = (length as u64).to_be_bytes();
251        let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
252        let num_octets = 8 - first_non_zero;
253        buf.push(0x80 | num_octets as u8);
254        buf.extend_from_slice(&bytes[first_non_zero..]);
255    }
256}
257
258#[cfg(test)]
259mod tests {
260    use super::*;
261
262    fn sample() -> Ipv6Setup {
263        Ipv6Setup::new(Ipv6SetupConfig {
264            logical_name: ObisCode::new(0, 0, 25, 7, 0, 255),
265            dl_reference: vec![0, 0, 25, 2, 0, 255],
266            address_config_mode: 0,
267            unicast_ipv6_addresses: vec![],
268            multicast_ipv6_addresses: vec![],
269            gateway_ipv6_addresses: vec![],
270            primary_dns_address: vec![0; 16],
271            secondary_dns_address: vec![0; 16],
272            traffic_class: 0,
273            neighbor_discovery_setup: vec![],
274        })
275    }
276
277    #[test]
278    fn class_id_and_attributes() {
279        let obj = sample();
280        assert_eq!(obj.class_id(), 48);
281        assert_eq!(obj.version(), 0);
282        assert_eq!(obj.attributes().len(), 10);
283        assert_eq!(obj.methods().len(), 2);
284    }
285
286    #[test]
287    fn round_trip() {
288        let obj = sample();
289        let mut buf = Vec::new();
290        obj.serialize_ber(&mut buf).unwrap();
291        let mut decoded = sample();
292        decoded.traffic_class = 9;
293        decoded.deserialize_ber(&buf).unwrap();
294        assert_eq!(decoded.attributes(), obj.attributes());
295    }
296
297    #[test]
298    fn add_remove_ipv6_address() {
299        let mut obj = sample();
300        let addr = CosemDataType::OctetString(vec![0xFEu8; 16]);
301        obj.invoke_method(1, Some(addr.clone())).unwrap();
302        assert_eq!(obj.unicast_ipv6_addresses.len(), 1);
303        obj.invoke_method(2, Some(addr)).unwrap();
304        assert_eq!(obj.unicast_ipv6_addresses.len(), 0);
305        assert!(obj.invoke_method(2, Some(CosemDataType::OctetString(vec![0x11; 16]))).is_err());
306    }
307}