use super::ServiceError;
pub const INITIATE_REQUEST_TAG: u8 = 0x01;
pub const INITIATE_RESPONSE_TAG: u8 = 0x08;
const CONFORMANCE_TAG: [u8; 2] = [0x5F, 0x1F];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InitiateRequest {
pub dedicated_key: Option<Vec<u8>>,
pub response_allowed: bool,
pub proposed_quality_of_service: Option<i8>,
pub proposed_dlms_version: u8,
pub proposed_conformance: u32,
pub client_max_receive_pdu_size: u16,
}
impl InitiateRequest {
pub fn encode(&self) -> Vec<u8> {
let mut buf = vec![INITIATE_REQUEST_TAG];
match &self.dedicated_key {
None => buf.push(0x00),
Some(key) => {
buf.push(0x01);
#[allow(clippy::cast_possible_truncation)]
let len = key.len() as u8;
buf.push(len);
buf.extend_from_slice(key);
}
}
if self.response_allowed {
buf.push(0x00); } else {
buf.push(0x01);
buf.push(0x00); }
match self.proposed_quality_of_service {
None => buf.push(0x00),
Some(q) => {
buf.push(0x01);
#[allow(clippy::cast_sign_loss)]
buf.push(q as u8);
}
}
buf.push(self.proposed_dlms_version);
push_conformance(self.proposed_conformance, &mut buf);
buf.extend_from_slice(&self.client_max_receive_pdu_size.to_be_bytes());
buf
}
pub fn decode(bytes: &[u8]) -> Result<InitiateRequest, ServiceError> {
if bytes.first() != Some(&INITIATE_REQUEST_TAG) {
return Err(ServiceError::UnexpectedTag(*bytes.first().unwrap_or(&0)));
}
let mut pos = 1;
let dedicated_key = match bytes.get(pos) {
Some(0x00) => {
pos += 1;
None
}
Some(0x01) => {
let len = *bytes.get(pos + 1).ok_or(ServiceError::Truncated)? as usize;
let start = pos + 2;
let key = bytes.get(start..start + len).ok_or(ServiceError::Truncated)?.to_vec();
pos = start + len;
Some(key)
}
Some(&other) => return Err(ServiceError::UnexpectedType(other)),
None => return Err(ServiceError::Truncated),
};
let response_allowed = match bytes.get(pos) {
Some(0x00) => {
pos += 1;
true
}
Some(0x01) => {
let value = *bytes.get(pos + 1).ok_or(ServiceError::Truncated)? != 0;
pos += 2;
value
}
Some(&other) => return Err(ServiceError::UnexpectedType(other)),
None => return Err(ServiceError::Truncated),
};
let proposed_quality_of_service = match bytes.get(pos) {
Some(0x00) => {
pos += 1;
None
}
Some(0x01) => {
#[allow(clippy::cast_possible_wrap)]
let q = *bytes.get(pos + 1).ok_or(ServiceError::Truncated)? as i8;
pos += 2;
Some(q)
}
Some(&other) => return Err(ServiceError::UnexpectedType(other)),
None => return Err(ServiceError::Truncated),
};
let proposed_dlms_version = *bytes.get(pos).ok_or(ServiceError::Truncated)?;
pos += 1;
let (proposed_conformance, n) = take_conformance(&bytes[pos..])?;
pos += n;
let b = bytes.get(pos..pos + 2).ok_or(ServiceError::Truncated)?;
let client_max_receive_pdu_size = u16::from_be_bytes([b[0], b[1]]);
Ok(InitiateRequest {
dedicated_key,
response_allowed,
proposed_quality_of_service,
proposed_dlms_version,
proposed_conformance,
client_max_receive_pdu_size,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InitiateResponse {
pub negotiated_quality_of_service: Option<i8>,
pub negotiated_dlms_version: u8,
pub negotiated_conformance: u32,
pub server_max_receive_pdu_size: u16,
pub vaa_name: u16,
}
impl InitiateResponse {
pub fn encode(&self) -> Vec<u8> {
let mut buf = vec![INITIATE_RESPONSE_TAG];
match self.negotiated_quality_of_service {
None => buf.push(0x00),
Some(q) => {
buf.push(0x01);
#[allow(clippy::cast_sign_loss)]
buf.push(q as u8);
}
}
buf.push(self.negotiated_dlms_version);
push_conformance(self.negotiated_conformance, &mut buf);
buf.extend_from_slice(&self.server_max_receive_pdu_size.to_be_bytes());
buf.extend_from_slice(&self.vaa_name.to_be_bytes());
buf
}
pub fn decode(bytes: &[u8]) -> Result<InitiateResponse, ServiceError> {
if bytes.first() != Some(&INITIATE_RESPONSE_TAG) {
return Err(ServiceError::UnexpectedTag(*bytes.first().unwrap_or(&0)));
}
let mut pos = 1;
let negotiated_quality_of_service = match bytes.get(pos) {
Some(0x00) => {
pos += 1;
None
}
Some(0x01) => {
#[allow(clippy::cast_possible_wrap)]
let q = *bytes.get(pos + 1).ok_or(ServiceError::Truncated)? as i8;
pos += 2;
Some(q)
}
Some(&other) => return Err(ServiceError::UnexpectedType(other)),
None => return Err(ServiceError::Truncated),
};
let negotiated_dlms_version = *bytes.get(pos).ok_or(ServiceError::Truncated)?;
pos += 1;
let (negotiated_conformance, n) = take_conformance(&bytes[pos..])?;
pos += n;
let b = bytes.get(pos..pos + 2).ok_or(ServiceError::Truncated)?;
let server_max_receive_pdu_size = u16::from_be_bytes([b[0], b[1]]);
pos += 2;
let v = bytes.get(pos..pos + 2).ok_or(ServiceError::Truncated)?;
let vaa_name = u16::from_be_bytes([v[0], v[1]]);
Ok(InitiateResponse {
negotiated_quality_of_service,
negotiated_dlms_version,
negotiated_conformance,
server_max_receive_pdu_size,
vaa_name,
})
}
}
fn push_conformance(conformance: u32, buf: &mut Vec<u8>) {
buf.extend_from_slice(&CONFORMANCE_TAG);
buf.push(0x04); buf.push(0x00); let b = conformance.to_be_bytes();
buf.extend_from_slice(&b[1..]); }
fn take_conformance(bytes: &[u8]) -> Result<(u32, usize), ServiceError> {
if bytes.get(..2) != Some(&CONFORMANCE_TAG[..]) {
return Err(ServiceError::InvalidData);
}
let len = *bytes.get(2).ok_or(ServiceError::Truncated)? as usize;
let value = bytes.get(3..3 + len).ok_or(ServiceError::Truncated)?;
let mut conformance = 0u32;
for &b in &value[1..] {
conformance = (conformance << 8) | u32::from(b);
}
Ok((conformance, 3 + len))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn initiate_request_matches_green_book_bytes() {
let req = InitiateRequest {
dedicated_key: None,
response_allowed: true,
proposed_quality_of_service: None,
proposed_dlms_version: 6,
proposed_conformance: 0x007E1F,
client_max_receive_pdu_size: 0x04B0,
};
let bytes = req.encode();
assert_eq!(bytes, vec![0x01, 0x00, 0x00, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x04, 0xB0]);
assert_eq!(InitiateRequest::decode(&bytes).unwrap(), req);
}
#[test]
fn initiate_response_matches_green_book_bytes() {
let resp = InitiateResponse {
negotiated_quality_of_service: None,
negotiated_dlms_version: 6,
negotiated_conformance: 0x007E1F,
server_max_receive_pdu_size: 0x01F4,
vaa_name: 0x0007,
};
let bytes = resp.encode();
assert_eq!(bytes, vec![0x08, 0x00, 0x06, 0x5F, 0x1F, 0x04, 0x00, 0x00, 0x7E, 0x1F, 0x01, 0xF4, 0x00, 0x07]);
assert_eq!(InitiateResponse::decode(&bytes).unwrap(), resp);
}
#[test]
fn initiate_request_with_dedicated_key_and_no_response_round_trips() {
let req = InitiateRequest {
dedicated_key: Some(vec![0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]),
response_allowed: false,
proposed_quality_of_service: Some(4),
proposed_dlms_version: 6,
proposed_conformance: 0x101D,
client_max_receive_pdu_size: 0x0200,
};
assert_eq!(InitiateRequest::decode(&req.encode()).unwrap(), req);
}
}