1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::ImageToActivateInfo;
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8pub mod transfer_status {
10 pub const NOT_INITIATED: u8 = 0;
12 pub const INITIATED: u8 = 1;
14 pub const VERIFICATION_INITIATED: u8 = 2;
16 pub const VERIFICATION_SUCCESSFUL: u8 = 3;
18 pub const VERIFICATION_FAILED: u8 = 4;
20 pub const ACTIVATION_INITIATED: u8 = 5;
22 pub const ACTIVATION_SUCCESSFUL: u8 = 6;
24 pub const ACTIVATION_FAILED: u8 = 7;
26}
27
28#[derive(Clone, Serialize, Deserialize, Debug)]
30pub struct ImageTransferConfig {
31 pub logical_name: ObisCode,
33 pub image_block_size: u32,
35 pub image_transferred_blocks_status: Vec<u8>,
37 pub image_first_not_transferred_block_number: u32,
39 pub image_transfer_enabled: bool,
41 pub image_transfer_status: u8,
43 pub image_to_activate_info: Vec<ImageToActivateInfo>,
45}
46
47#[derive(Clone, Serialize, Deserialize, Debug)]
53pub struct ImageTransfer {
54 logical_name: ObisCode,
55 image_block_size: u32,
56 image_transferred_blocks_status: Vec<u8>,
57 image_first_not_transferred_block_number: u32,
58 image_transfer_enabled: bool,
59 image_transfer_status: u8,
60 image_to_activate_info: Vec<ImageToActivateInfo>,
61}
62
63impl ImageTransfer {
64 pub fn new(config: ImageTransferConfig) -> Self {
66 ImageTransfer {
67 logical_name: config.logical_name,
68 image_block_size: config.image_block_size,
69 image_transferred_blocks_status: config.image_transferred_blocks_status,
70 image_first_not_transferred_block_number: config.image_first_not_transferred_block_number,
71 image_transfer_enabled: config.image_transfer_enabled,
72 image_transfer_status: config.image_transfer_status,
73 image_to_activate_info: config.image_to_activate_info,
74 }
75 }
76
77 fn ensure_enabled(&self) -> Result<(), String> {
78 if self.image_transfer_enabled {
79 Ok(())
80 } else {
81 Err("Image transfer is disabled".to_string())
82 }
83 }
84
85 fn image_transfer_initiate(&mut self, _data: CosemDataType) -> Result<CosemDataType, String> {
89 self.ensure_enabled()?;
90 self.image_transferred_blocks_status.clear();
91 self.image_first_not_transferred_block_number = 0;
92 self.image_transfer_status = transfer_status::INITIATED;
93 Ok(CosemDataType::Null)
94 }
95
96 fn image_block_transfer(&mut self, data: CosemDataType) -> Result<CosemDataType, String> {
100 self.ensure_enabled()?;
101 let block_number = match data {
102 CosemDataType::Structure(fields) if !fields.is_empty() => match &fields[0] {
103 CosemDataType::DoubleLongUnsigned(n) => *n,
104 _ => return Err("image_block_number must be double-long-unsigned".to_string()),
105 },
106 _ => return Err("Expected structure { image_block_number, image_block_value }".to_string()),
107 };
108 self.set_block_transferred(block_number);
109 self.image_first_not_transferred_block_number = self.first_clear_bit();
110 Ok(CosemDataType::Null)
111 }
112
113 fn image_verify(&mut self, _data: CosemDataType) -> Result<CosemDataType, String> {
116 self.ensure_enabled()?;
117 self.image_transfer_status = transfer_status::VERIFICATION_SUCCESSFUL;
118 Ok(CosemDataType::Null)
119 }
120
121 fn image_activate(&mut self, _data: CosemDataType) -> Result<CosemDataType, String> {
124 self.ensure_enabled()?;
125 self.image_transfer_status = transfer_status::ACTIVATION_SUCCESSFUL;
126 Ok(CosemDataType::Null)
127 }
128
129 fn set_block_transferred(&mut self, block_number: u32) {
131 let byte_index = (block_number / 8) as usize;
132 if byte_index >= self.image_transferred_blocks_status.len() {
133 self.image_transferred_blocks_status.resize(byte_index + 1, 0);
134 }
135 let bit = 7 - (block_number % 8) as u8;
136 self.image_transferred_blocks_status[byte_index] |= 1 << bit;
137 }
138
139 #[allow(clippy::cast_possible_truncation)]
143 fn first_clear_bit(&self) -> u32 {
144 for (byte_index, byte) in self.image_transferred_blocks_status.iter().enumerate() {
145 for bit in 0..8u32 {
146 if byte & (1 << (7 - bit)) == 0 {
147 return byte_index as u32 * 8 + bit;
148 }
149 }
150 }
151 self.image_transferred_blocks_status.len() as u32 * 8
152 }
153}
154
155impl InterfaceClass for ImageTransfer {
156 fn class_id(&self) -> u16 {
157 18
158 }
159
160 fn version(&self) -> u8 {
161 0
162 }
163
164 fn logical_name(&self) -> &ObisCode {
165 &self.logical_name
166 }
167
168 fn attributes(&self) -> Vec<(u8, CosemDataType)> {
169 vec![
170 (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
171 (2, CosemDataType::DoubleLongUnsigned(self.image_block_size)),
172 (3, CosemDataType::BitString(self.image_transferred_blocks_status.clone())),
173 (4, CosemDataType::DoubleLongUnsigned(self.image_first_not_transferred_block_number)),
174 (5, CosemDataType::Boolean(self.image_transfer_enabled)),
175 (6, CosemDataType::Enum(self.image_transfer_status)),
176 (7, CosemDataType::Array(self.image_to_activate_info.iter().cloned().map(CosemDataType::from).collect())),
177 ]
178 }
179
180 fn methods(&self) -> Vec<(u8, String)> {
181 vec![
182 (1, "image_transfer_initiate".to_string()),
183 (2, "image_block_transfer".to_string()),
184 (3, "image_verify".to_string()),
185 (4, "image_activate".to_string()),
186 ]
187 }
188
189 fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
190 let mut seq_buf = Vec::new();
191 CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
192 for (_, attr) in self.attributes() {
193 attr.serialize_ber(&mut seq_buf)?;
194 }
195 buf.push(0x02); write_length(1 + self.attributes().len(), buf); buf.extend_from_slice(&seq_buf);
198 Ok(())
199 }
200
201 fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
202 let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
203 if !rest.is_empty() {
204 return Err(BerError::InvalidTag);
205 }
206 let CosemDataType::Structure(seq) = tlv else {
207 return Err(BerError::InvalidTag);
208 };
209 if seq.len() != 8 {
211 return Err(BerError::InvalidLength);
212 }
213 if let CosemDataType::LongUnsigned(class_id) = seq[0] {
214 if class_id != self.class_id() {
215 return Err(BerError::InvalidValue);
216 }
217 } else {
218 return Err(BerError::InvalidTag);
219 }
220 if let CosemDataType::OctetString(obis) = &seq[1] {
221 if obis.len() == 6 {
222 self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
223 } else {
224 return Err(BerError::InvalidLength);
225 }
226 } else {
227 return Err(BerError::InvalidTag);
228 }
229 self.image_block_size = match seq[2] {
230 CosemDataType::DoubleLongUnsigned(v) => v,
231 _ => return Err(BerError::InvalidTag),
232 };
233 self.image_transferred_blocks_status = match &seq[3] {
234 CosemDataType::BitString(v) => v.clone(),
235 _ => return Err(BerError::InvalidTag),
236 };
237 self.image_first_not_transferred_block_number = match seq[4] {
238 CosemDataType::DoubleLongUnsigned(v) => v,
239 _ => return Err(BerError::InvalidTag),
240 };
241 self.image_transfer_enabled = match seq[5] {
242 CosemDataType::Boolean(v) => v,
243 _ => return Err(BerError::InvalidTag),
244 };
245 self.image_transfer_status = match seq[6] {
246 CosemDataType::Enum(v) => v,
247 _ => return Err(BerError::InvalidTag),
248 };
249 self.image_to_activate_info = match &seq[7] {
250 CosemDataType::Array(list) => list
251 .iter()
252 .map(ImageToActivateInfo::try_from)
253 .collect::<Result<Vec<_>, _>>()
254 .map_err(|_| BerError::InvalidValue)?,
255 _ => return Err(BerError::InvalidTag),
256 };
257 Ok(())
258 }
259
260 fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
261 let params = params.ok_or("Missing method parameter")?;
262 match method_id {
263 1 => self.image_transfer_initiate(params),
264 2 => self.image_block_transfer(params),
265 3 => self.image_verify(params),
266 4 => self.image_activate(params),
267 _ => Err(format!("Method {method_id} not supported for Image transfer")),
268 }
269 }
270
271 fn as_any(&self) -> &dyn Any {
272 self
273 }
274}
275
276#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
279 if length < 128 {
280 buf.push(length as u8);
281 } else {
282 let bytes = (length as u64).to_be_bytes();
283 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
284 let num_octets = 8 - first_non_zero;
285 buf.push(0x80 | num_octets as u8);
286 buf.extend_from_slice(&bytes[first_non_zero..]);
287 }
288}
289
290#[cfg(test)]
291mod tests {
292 use super::*;
293
294 fn sample() -> ImageTransfer {
295 ImageTransfer::new(ImageTransferConfig {
296 logical_name: ObisCode::new(0, 0, 44, 0, 0, 255),
297 image_block_size: 256,
298 image_transferred_blocks_status: vec![],
299 image_first_not_transferred_block_number: 0,
300 image_transfer_enabled: true,
301 image_transfer_status: transfer_status::NOT_INITIATED,
302 image_to_activate_info: vec![],
303 })
304 }
305
306 #[test]
307 fn class_id_and_attributes() {
308 let obj = sample();
309 assert_eq!(obj.class_id(), 18);
310 assert_eq!(obj.version(), 0);
311 assert_eq!(obj.attributes().len(), 7);
312 assert_eq!(obj.methods().len(), 4);
313 }
314
315 #[test]
316 fn round_trip() {
317 let mut obj = sample();
318 obj.image_transferred_blocks_status = vec![0b1010_0000];
319 obj.image_transfer_status = transfer_status::INITIATED;
320 let mut buf = Vec::new();
321 obj.serialize_ber(&mut buf).unwrap();
322 let mut decoded = sample();
323 decoded.deserialize_ber(&buf).unwrap();
324 assert_eq!(decoded.attributes(), obj.attributes());
325 }
326
327 #[test]
328 fn transfer_flow_marks_blocks_and_advances_status() {
329 let mut obj = sample();
330 obj.invoke_method(
331 1,
332 Some(CosemDataType::Structure(vec![
333 CosemDataType::OctetString(b"fw".to_vec()),
334 CosemDataType::DoubleLongUnsigned(512),
335 ])),
336 )
337 .unwrap();
338 assert_eq!(obj.attributes()[5].1, CosemDataType::Enum(transfer_status::INITIATED));
339
340 obj.invoke_method(
342 2,
343 Some(CosemDataType::Structure(vec![
344 CosemDataType::DoubleLongUnsigned(0),
345 CosemDataType::OctetString(vec![0xAB; 4]),
346 ])),
347 )
348 .unwrap();
349 assert_eq!(obj.attributes()[3].1, CosemDataType::DoubleLongUnsigned(1));
350
351 obj.invoke_method(3, Some(CosemDataType::Integer(0))).unwrap();
352 assert_eq!(obj.attributes()[5].1, CosemDataType::Enum(transfer_status::VERIFICATION_SUCCESSFUL));
353 obj.invoke_method(4, Some(CosemDataType::Integer(0))).unwrap();
354 assert_eq!(obj.attributes()[5].1, CosemDataType::Enum(transfer_status::ACTIVATION_SUCCESSFUL));
355 }
356
357 #[test]
358 fn methods_fail_when_disabled() {
359 let mut obj = sample();
360 obj.image_transfer_enabled = false;
361 assert!(obj.invoke_method(1, Some(CosemDataType::Null)).is_err());
362 }
363}