#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MeshAddress(u16);
impl MeshAddress {
pub const fn new(value: u16) -> Option<Self> {
if value == 0 {
None
} else {
Some(Self(value))
}
}
pub const fn get(self) -> u16 {
self.0
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MeshNetworkPdu(Vec<u8>);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NetworkHeader {
pub ivi: bool,
pub ctl: bool,
pub ttl: u8,
pub sequence: u32,
pub source: MeshAddress,
pub destination: MeshAddress,
}
impl MeshNetworkPdu {
pub const MAX_LEN: usize = 29;
pub fn new(bytes: Vec<u8>) -> Option<Self> {
(!bytes.is_empty() && bytes.len() <= Self::MAX_LEN).then_some(Self(bytes))
}
pub fn from_slice(bytes: &[u8]) -> Option<Self> {
Self::new(bytes.to_vec())
}
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
pub fn header(&self) -> Option<NetworkHeader> {
if self.0.len() < 10 {
return None;
}
let ivi_ctl_ttl = self.0[0];
let sequence = u32::from_be_bytes([0, self.0[1], self.0[2], self.0[3]]);
let source = MeshAddress::new(u16::from_be_bytes([self.0[4], self.0[5]]))?;
let destination = MeshAddress::new(u16::from_be_bytes([self.0[6], self.0[7]]))?;
Some(NetworkHeader {
ivi: ivi_ctl_ttl & 1 != 0,
ctl: ivi_ctl_ttl & 2 != 0,
ttl: (ivi_ctl_ttl >> 2) & 0x7f,
sequence,
source,
destination,
})
}
}
impl NetworkHeader {
pub fn encode(self, payload: &[u8]) -> Option<MeshNetworkPdu> {
if self.ttl > 0x7f || self.sequence > 0x00ff_ffff || payload.is_empty() {
return None;
}
let total_len = 8usize.checked_add(payload.len())?;
if total_len > MeshNetworkPdu::MAX_LEN {
return None;
}
let mut bytes = Vec::with_capacity(total_len);
bytes.push((self.ivi as u8) | ((self.ctl as u8) << 1) | (self.ttl << 2));
bytes.extend_from_slice(&self.sequence.to_be_bytes()[1..]);
bytes.extend_from_slice(&self.source.get().to_be_bytes());
bytes.extend_from_slice(&self.destination.get().to_be_bytes());
bytes.extend_from_slice(payload);
MeshNetworkPdu::new(bytes)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ProvisioningState {
#[default]
Idle,
WaitingForCapabilities,
Authenticating,
DistributingKeys,
Complete,
Failed,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProvisioningEvent {
Capabilities {
algorithms: Vec<u8>,
public_key_type: u8,
},
AuthenticationRequired,
Complete {
address: MeshAddress,
},
Failed {
reason: ProvisioningFailure,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProvisioningFailure {
Rejected,
Authentication,
Timeout,
Disconnected,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProvisioningTransitionError {
InvalidTransition {
state: ProvisioningState,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct ProvisioningSession {
state: ProvisioningState,
}
impl ProvisioningSession {
pub const fn new() -> Self {
Self {
state: ProvisioningState::Idle,
}
}
pub const fn state(self) -> ProvisioningState {
self.state
}
pub fn start(&mut self) -> bool {
if self.state != ProvisioningState::Idle {
return false;
}
self.state = ProvisioningState::WaitingForCapabilities;
true
}
pub fn apply(&mut self, event: &ProvisioningEvent) -> ProvisioningState {
self.state = match event {
ProvisioningEvent::Capabilities { .. } | ProvisioningEvent::AuthenticationRequired => {
ProvisioningState::Authenticating
}
ProvisioningEvent::Complete { .. } => ProvisioningState::Complete,
ProvisioningEvent::Failed { .. } => ProvisioningState::Failed,
};
self.state
}
pub fn try_apply(
&mut self,
event: &ProvisioningEvent,
) -> Result<ProvisioningState, ProvisioningTransitionError> {
let next = match (self.state, event) {
(
ProvisioningState::WaitingForCapabilities,
ProvisioningEvent::Capabilities { .. } | ProvisioningEvent::AuthenticationRequired,
) => ProvisioningState::Authenticating,
(
ProvisioningState::WaitingForCapabilities
| ProvisioningState::Authenticating
| ProvisioningState::DistributingKeys,
ProvisioningEvent::Failed { .. },
) => ProvisioningState::Failed,
(
ProvisioningState::Authenticating | ProvisioningState::DistributingKeys,
ProvisioningEvent::Complete { .. },
) => ProvisioningState::Complete,
(state, _) => {
return Err(ProvisioningTransitionError::InvalidTransition { state });
}
};
self.state = next;
Ok(next)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn provisioning_session_transitions_and_rejects_restart() {
let mut session = ProvisioningSession::new();
assert!(session.start());
assert!(!session.start());
session.apply(&ProvisioningEvent::Capabilities {
algorithms: vec![0],
public_key_type: 0,
});
assert_eq!(session.state(), ProvisioningState::Authenticating);
session.apply(&ProvisioningEvent::Complete {
address: MeshAddress::new(1).unwrap(),
});
assert_eq!(session.state(), ProvisioningState::Complete);
}
#[test]
fn checked_provisioning_transitions_reject_without_mutating() {
let mut session = ProvisioningSession::new();
assert_eq!(
session.try_apply(&ProvisioningEvent::Complete {
address: MeshAddress::new(1).unwrap(),
}),
Err(ProvisioningTransitionError::InvalidTransition {
state: ProvisioningState::Idle
})
);
assert!(session.start());
assert!(session
.try_apply(&ProvisioningEvent::Complete {
address: MeshAddress::new(1).unwrap(),
})
.is_err());
assert_eq!(session.state(), ProvisioningState::WaitingForCapabilities);
assert_eq!(
session
.try_apply(&ProvisioningEvent::Capabilities {
algorithms: vec![0],
public_key_type: 0,
})
.unwrap(),
ProvisioningState::Authenticating
);
assert_eq!(
session
.try_apply(&ProvisioningEvent::Complete {
address: MeshAddress::new(1).unwrap(),
})
.unwrap(),
ProvisioningState::Complete
);
assert!(session
.try_apply(&ProvisioningEvent::Failed {
reason: ProvisioningFailure::Timeout,
})
.is_err());
}
#[test]
fn checked_provisioning_accepts_failure_while_active() {
for event in [
ProvisioningEvent::Capabilities {
algorithms: vec![],
public_key_type: 0,
},
ProvisioningEvent::AuthenticationRequired,
] {
let mut session = ProvisioningSession::new();
assert!(session.start());
let _ = session.try_apply(&event);
assert_eq!(
session
.try_apply(&ProvisioningEvent::Failed {
reason: ProvisioningFailure::Disconnected,
})
.unwrap(),
ProvisioningState::Failed
);
}
}
#[test]
fn parses_network_header_metadata() {
let pdu = MeshNetworkPdu::new(vec![0x15, 0x01, 0x02, 0x03, 0x00, 0x01, 0xc0, 0x01, 0, 0])
.unwrap();
let header = pdu.header().unwrap();
assert!(header.ivi);
assert!(!header.ctl);
assert_eq!(header.ttl, 5);
assert_eq!(header.sequence, 0x010203);
assert_eq!(header.source.get(), 1);
assert_eq!(header.destination.get(), 0xc001);
}
#[test]
fn encodes_and_decodes_network_header() {
let header = NetworkHeader {
ivi: true,
ctl: false,
ttl: 5,
sequence: 0x010203,
source: MeshAddress::new(1).unwrap(),
destination: MeshAddress::new(0xc001).unwrap(),
};
let pdu = header.encode(&[0xaa, 0xbb]).unwrap();
assert_eq!(
pdu.as_bytes(),
&[0x15, 0x01, 0x02, 0x03, 0, 1, 0xc0, 1, 0xaa, 0xbb]
);
assert_eq!(pdu.header(), Some(header));
assert_eq!(MeshNetworkPdu::from_slice(pdu.as_bytes()), Some(pdu));
}
#[test]
fn rejects_invalid_network_header_encodings() {
let header = NetworkHeader {
ivi: false,
ctl: false,
ttl: 0,
sequence: 0,
source: MeshAddress::new(1).unwrap(),
destination: MeshAddress::new(2).unwrap(),
};
assert!(header.encode(&[]).is_none());
assert!(NetworkHeader { ttl: 128, ..header }.encode(&[0]).is_none());
assert!(NetworkHeader {
sequence: 0x0100_0000,
..header
}
.encode(&[0])
.is_none());
assert!(header.encode(&[0; 22]).is_none());
}
}