pub trait Config {
const FABRICS: usize = 5;
const SESSIONS: usize = 16;
const EXCHANGES_PER_SESSION: usize = 4;
const SUBSCRIPTIONS: usize = 15;
const SUBSCRIPTIONS_PER_FABRIC: usize = 3;
const SUB_PATHS: usize = 3;
const READ_PATHS: usize = 9;
const ACL_ENTRIES: usize = 4 * Self::FABRICS;
const ACL_ENTRIES_PER_FABRIC: usize = 4;
const ACL_SUBJECTS: usize = 4;
const ACL_TARGETS: usize = 3;
const ACL_AUXILIARY: bool = false;
const GROUPS: usize = 4 * Self::FABRICS;
const GROUP_KEYS: usize = 3 * Self::FABRICS;
const MAX_TCP_MSG: usize = 64 * 1024;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DefaultConfig;
impl Config for DefaultConfig {}
pub const MAX_UDP_MESSAGE: usize = 1280;
pub const MAX_MESSAGE_FRAMING: usize = (8 + 8 + 8) + (6 + 2 + 4) + 16;
pub const MAX_UDP_PAYLOAD: usize = MAX_UDP_MESSAGE.saturating_sub(MAX_MESSAGE_FRAMING);
pub struct AssertValid<C: Config>(core::marker::PhantomData<C>);
impl<C: Config> AssertValid<C> {
pub const CHECK: () = {
assert!(
C::FABRICS >= 5,
"Config::FABRICS: Core §11.18.5.3 constrains SupportedFabrics to 5..=254"
);
assert!(
C::FABRICS <= 254,
"Config::FABRICS: Core §11.18.5.3 constrains SupportedFabrics to 5..=254"
);
assert!(
C::ACL_ENTRIES >= 4 * C::FABRICS,
"Config::ACL_ENTRIES: Core §2.11.1.1 requires at least 4 entries per fabric"
);
assert!(
C::GROUP_KEYS >= 3 * C::FABRICS,
"Config::GROUP_KEYS: Core §2.11.1.2 requires at least 3 group keys per fabric"
);
assert!(
C::SESSIONS >= 3 * C::FABRICS,
"Config::SESSIONS: Core §4.14.2.8 requires at least 3 CASE sessions per fabric"
);
assert!(
C::SUBSCRIPTIONS_PER_FABRIC >= 3,
"Config::SUBSCRIPTIONS_PER_FABRIC: Core §2.11.2.2 requires at least 3 per fabric"
);
assert!(
C::SUBSCRIPTIONS >= C::SUBSCRIPTIONS_PER_FABRIC * C::FABRICS,
"Config::SUBSCRIPTIONS: every fabric must be able to reach SUBSCRIPTIONS_PER_FABRIC"
);
assert!(
C::SUBSCRIPTIONS >= 3 * C::FABRICS,
"Config::SUBSCRIPTIONS: Core §2.11.2.2 requires at least 3 subscriptions per fabric"
);
assert!(
C::SUB_PATHS >= 3,
"Config::SUB_PATHS: Core §2.11.2.2 requires at least 3 paths per subscription"
);
assert!(
C::READ_PATHS >= 9,
"Config::READ_PATHS: Core §2.11.2.1 requires a read of up to 9 paths"
);
assert!(
C::EXCHANGES_PER_SESSION >= 1,
"Config::EXCHANGES_PER_SESSION: a session with no exchange can do nothing"
);
};
}
pub const fn assert_valid<C: Config>() {
#[allow(clippy::let_unit_value)]
let () = AssertValid::<C>::CHECK;
}
#[cfg(test)]
mod tests {
use super::*;
const _: () = assert_valid::<DefaultConfig>();
#[test]
fn the_default_config_satisfies_every_minimum() {
assert_valid::<DefaultConfig>();
}
#[test]
fn derived_defaults_follow_the_fabric_count() {
#[derive(Debug)]
struct Big;
impl Config for Big {
const FABRICS: usize = 16;
const SESSIONS: usize = 64;
const SUBSCRIPTIONS: usize = 48;
}
const _: () = assert_valid::<Big>();
assert_eq!(Big::ACL_ENTRIES, 64);
assert_eq!(Big::GROUP_KEYS, 48);
}
#[test]
fn max_udp_message_is_the_ipv6_minimum_mtu() {
assert_eq!(MAX_UDP_MESSAGE, 1280);
}
}
#[cfg(test)]
mod payload_bound {
use super::{MAX_MESSAGE_FRAMING, MAX_UDP_MESSAGE, MAX_UDP_PAYLOAD};
use crate::msg::{
Destination, MessageHeader, NodeId, ProtocolHeader, ProtocolId, SessionId, SessionType,
};
#[test]
fn the_framing_bound_is_what_the_headers_encode() {
let message = MessageHeader {
session_id: SessionId(0x1234),
session_type: SessionType::Unicast,
privacy: false,
control: false,
message_counter: 0xDEAD_BEEF,
source: Some(NodeId(0x0102_0304_0506_0708)),
destination: Destination::Node(NodeId(0x1112_1314_1516_1718)),
};
let protocol = ProtocolHeader {
acknowledged_counter: Some(0x0BAD_F00D),
protocol: ProtocolId {
vendor: crate::msg::VendorId(0xFFF1),
id: 0x0001,
},
..ProtocolHeader::default()
};
let encoded = message.encoded_len() + protocol.encoded_len();
let mic = crate::crypto::AEAD_MIC_LENGTH_BYTES;
assert_eq!(
encoded + mic,
MAX_MESSAGE_FRAMING,
"the framing bound no longer matches what the headers encode"
);
assert_eq!(MAX_UDP_PAYLOAD + MAX_MESSAGE_FRAMING, MAX_UDP_MESSAGE);
}
}