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#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct Ipv6SetupConfig {
11 pub logical_name: ObisCode,
13 pub dl_reference: Vec<u8>,
15 pub address_config_mode: u8,
17 pub unicast_ipv6_addresses: Vec<Vec<u8>>,
19 pub multicast_ipv6_addresses: Vec<Vec<u8>>,
21 pub gateway_ipv6_addresses: Vec<Vec<u8>>,
23 pub primary_dns_address: Vec<u8>,
25 pub secondary_dns_address: Vec<u8>,
27 pub traffic_class: u8,
29 pub neighbor_discovery_setup: Vec<NeighborDiscoverySetup>,
31}
32
33#[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 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 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 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); write_length(1 + self.attributes().len(), buf); 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 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(¶ms.ok_or("Missing method parameter")?),
205 2 => self.remove_ipv6_address(¶ms.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#[allow(clippy::cast_possible_truncation)] fn 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}