use crate::bytes::Cursor;
use crate::error::{Error, ErrorCode, Result, bail};
use crate::platform::{Duration, Instant};
pub const OPCODE_HANDSHAKE: u8 = 0x6C;
pub const VERSION: u8 = 4;
pub const MIN_ATT_MTU: u16 = 23;
pub const GATT_HEADER: u16 = 3;
pub const MAX_SEGMENT: u16 = 244;
pub const CONN_RSP_TIMEOUT: Duration = Duration::from_secs(5);
pub const ACK_TIMEOUT: Duration = Duration::from_secs(15);
pub const CONN_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
pub const SEND_ACK_TIMEOUT: Duration = Duration::from_secs(5);
pub const MAX_WINDOW: u8 = 255;
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Flags: u8 {
const BEGINNING = 1 << 0;
const CONTINUING = 1 << 1;
const ENDING = 1 << 2;
const ACK = 1 << 3;
const MANAGEMENT = 1 << 5;
const HANDSHAKE = 1 << 6;
}
}
pub const HANDSHAKE_FLAGS: u8 = 0x65;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Role {
Client,
Server,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HandshakeRequest {
pub versions: [u8; 8],
pub att_mtu: u16,
pub window: u8,
}
impl HandshakeRequest {
pub const LEN: usize = 9;
#[must_use]
pub const fn new(att_mtu: u16, window: u8) -> Self {
let mut versions = [0u8; 8];
versions[0] = VERSION;
Self {
versions,
att_mtu,
window,
}
}
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = Cursor::writer(out);
w.u8(HANDSHAKE_FLAGS)?;
w.u8(OPCODE_HANDSHAKE)?;
for &[low, high] in self.versions.as_chunks::<2>().0 {
w.u8((low & 0x0F) | ((high & 0x0F) << 4))?;
}
w.u16(self.att_mtu)?;
w.u8(self.window)?;
Ok(w.position())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut r = Cursor::reader(buf, ErrorCode::BtpMalformed);
if r.read_u8()? != HANDSHAKE_FLAGS || r.read_u8()? != OPCODE_HANDSHAKE {
bail!(BtpMalformed)
}
let mut versions = [0u8; 8];
for [low, high] in versions.as_chunks_mut::<2>().0 {
let octet = r.read_u8()?;
*low = octet & 0x0F;
*high = octet >> 4;
}
Ok(Self {
versions,
att_mtu: r.read_u16()?,
window: r.read_u8()?,
})
}
#[must_use]
pub fn best_version(&self) -> Option<u8> {
self.versions
.iter()
.copied()
.find(|&v| v != 0 && v <= VERSION)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HandshakeResponse {
pub version: u8,
pub att_mtu: u16,
pub window: u8,
}
impl HandshakeResponse {
pub const LEN: usize = 6;
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let mut w = Cursor::writer(out);
w.u8(HANDSHAKE_FLAGS)?;
w.u8(OPCODE_HANDSHAKE)?;
w.u8(self.version & 0x0F)?;
w.u16(self.att_mtu)?;
w.u8(self.window)?;
Ok(w.position())
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut r = Cursor::reader(buf, ErrorCode::BtpMalformed);
if r.read_u8()? != HANDSHAKE_FLAGS || r.read_u8()? != OPCODE_HANDSHAKE {
bail!(BtpMalformed)
}
Ok(Self {
version: r.read_u8()? & 0x0F,
att_mtu: r.read_u16()?,
window: r.read_u8()?,
})
}
#[must_use]
pub const fn params(&self) -> SessionParams {
SessionParams {
segment_size: self.segment_size(),
window: self.window,
}
}
#[must_use]
pub const fn segment_size(&self) -> usize {
let mtu = if self.att_mtu < MIN_ATT_MTU {
MIN_ATT_MTU
} else {
self.att_mtu
};
let usable = mtu.saturating_sub(GATT_HEADER);
(if usable > MAX_SEGMENT {
MAX_SEGMENT
} else {
usable
}) as usize
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SessionParams {
pub segment_size: usize,
pub window: u8,
}
pub fn negotiate(
request: &HandshakeRequest,
own_att_mtu: u16,
own_window: u8,
) -> Result<HandshakeResponse> {
let Some(version) = request.best_version() else {
bail!(UnsupportedVersion)
};
let requested = if request.att_mtu == 0 {
own_att_mtu
} else {
request.att_mtu.min(own_att_mtu)
};
let window = request.window.min(own_window);
if window == 0 {
bail!(BtpMalformed)
}
Ok(HandshakeResponse {
version,
att_mtu: requested.max(MIN_ATT_MTU),
window,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Frame<'a> {
pub flags: Flags,
pub ack: Option<u8>,
pub sequence: u8,
pub message_length: Option<u16>,
pub payload: &'a [u8],
}
impl<'a> Frame<'a> {
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut r = Cursor::reader(buf, ErrorCode::BtpMalformed);
let flags = Flags::from_bits_truncate(r.read_u8()?);
if flags.intersects(Flags::HANDSHAKE | Flags::MANAGEMENT) {
bail!(BtpMalformed)
}
let ack = if flags.contains(Flags::ACK) {
Some(r.read_u8()?)
} else {
None
};
let sequence = r.read_u8()?;
let message_length = if flags.contains(Flags::BEGINNING) {
Some(r.read_u16()?)
} else {
None
};
Ok(Self {
flags,
ack,
sequence,
message_length,
payload: r.rest(),
})
}
#[must_use]
pub const fn header_len(ack: bool, beginning: bool) -> usize {
2usize
.saturating_add(ack as usize)
.saturating_add(if beginning { 2 } else { 0 })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Received {
Message,
Partial,
Ack,
}
#[derive(Debug)]
pub struct Session<const SDU: usize> {
role: Role,
segment_size: usize,
max_window: u8,
tx_sequence: u8,
tx_acked: u8,
rx_sequence: u8,
rx_acked: u8,
pending_ack: Option<u8>,
send_ack_at: Option<Instant>,
ack_deadline: Option<Instant>,
last_data: Instant,
closed: Option<ErrorCode>,
rx: [u8; SDU],
rx_len: usize,
rx_expected: Option<u16>,
tx: [u8; SDU],
tx_len: usize,
tx_sent: usize,
tx_active: bool,
}
impl<const SDU: usize> Session<SDU> {
#[must_use]
pub fn new(role: Role, params: &SessionParams, now: Instant) -> Self {
let (tx_sequence, rx_sequence, pending_ack, send_ack_at, ack_deadline) = match role {
Role::Client => (
0,
0,
Some(0),
Some(now.saturating_add(SEND_ACK_TIMEOUT)),
None,
),
Role::Server => (1, 255, None, None, Some(now.saturating_add(ACK_TIMEOUT))),
};
Self {
role,
segment_size: params.segment_size,
max_window: params.window,
tx_sequence,
tx_acked: 255,
rx_sequence,
rx_acked: 255,
pending_ack,
send_ack_at,
ack_deadline,
last_data: now,
closed: None,
rx: [0u8; SDU],
rx_len: 0,
rx_expected: None,
tx: [0u8; SDU],
tx_len: 0,
tx_sent: 0,
tx_active: false,
}
}
#[must_use]
pub const fn role(&self) -> Role {
self.role
}
#[must_use]
pub const fn is_closed(&self) -> bool {
self.closed.is_some()
}
#[must_use]
pub const fn close_reason(&self) -> Option<ErrorCode> {
self.closed
}
fn guard(&self) -> Result<()> {
match self.closed {
Some(code) => Err(Error::new(code)),
None => Ok(()),
}
}
fn fail<T>(&mut self, result: Result<T>) -> Result<T> {
if let Err(error) = &result {
self.closed = Some(error.code());
}
result
}
#[must_use]
pub const fn segment_size(&self) -> usize {
self.segment_size
}
#[must_use]
pub const fn in_flight(&self) -> u8 {
self.tx_sequence.wrapping_sub(self.tx_acked).wrapping_sub(1)
}
#[must_use]
pub const fn remote_window(&self) -> u8 {
self.max_window.saturating_sub(self.in_flight())
}
#[must_use]
pub const fn own_window_free(&self) -> u8 {
self.max_window
.saturating_sub(self.rx_sequence.wrapping_sub(self.rx_acked))
}
#[must_use]
pub const fn owes_ack(&self) -> bool {
self.pending_ack.is_some()
}
#[must_use]
pub const fn is_sending(&self) -> bool {
self.tx_active
}
pub fn send(&mut self, sdu: &[u8]) -> Result<()> {
self.guard()?;
if self.tx_active {
bail!(Busy)
}
if sdu.is_empty() {
bail!(InvalidArgument)
}
let Some(slot) = self.tx.get_mut(..sdu.len()) else {
bail!(BufferTooSmall)
};
slot.copy_from_slice(sdu);
self.tx_len = sdu.len();
self.tx_sent = 0;
self.tx_active = true;
Ok(())
}
#[must_use]
pub const fn can_send(&self) -> bool {
match self.remote_window() {
0 => false,
1 => self.pending_ack.is_some(),
_ => true,
}
}
pub fn poll_send(&mut self, now: Instant, out: &mut [u8]) -> Result<Option<usize>> {
self.guard()?;
let result = self.poll_send_inner(now, out);
self.fail(result)
}
fn poll_send_inner(&mut self, now: Instant, out: &mut [u8]) -> Result<Option<usize>> {
if !self.can_send() {
return Ok(None);
}
let ack_due =
self.own_window_free() <= 2 || self.send_ack_at.is_some_and(|deadline| now >= deadline);
if !self.tx_active {
if self.pending_ack.is_some() && ack_due {
return Ok(Some(self.write_header(now, false, false, 0, out)?));
}
return Ok(None);
}
let remaining = self.tx_len.saturating_sub(self.tx_sent);
let beginning = self.tx_sent == 0;
let room = self
.segment_size
.saturating_sub(Frame::header_len(self.pending_ack.is_some(), beginning));
if room == 0 {
bail!(BufferTooSmall)
}
let take = remaining.min(room);
let ending = take == remaining;
let at = self.write_header(now, beginning, ending, take, out)?;
let end = at.saturating_add(take);
let sent_to = self.tx_sent.saturating_add(take);
let (Some(slot), Some(segment)) =
(out.get_mut(at..end), self.tx.get(self.tx_sent..sent_to))
else {
bail!(BufferTooSmall)
};
slot.copy_from_slice(segment);
self.tx_sent = sent_to;
self.last_data = now;
if ending {
self.tx_active = false;
self.tx_len = 0;
self.tx_sent = 0;
}
Ok(Some(end))
}
fn write_header(
&mut self,
now: Instant,
beginning: bool,
ending: bool,
payload_len: usize,
out: &mut [u8],
) -> Result<usize> {
let mut flags = Flags::empty();
if beginning {
flags |= Flags::BEGINNING;
} else if payload_len > 0 {
flags |= Flags::CONTINUING;
}
if ending {
flags |= Flags::ENDING;
}
let ack = self.pending_ack;
if ack.is_some() {
flags |= Flags::ACK;
}
let len = {
let mut w = Cursor::writer(out);
w.u8(flags.bits())?;
if let Some(ack) = ack {
w.u8(ack)?;
}
w.u8(self.tx_sequence)?;
if beginning {
let length = u16::try_from(self.tx_len)
.map_err(|_| Error::new(ErrorCode::BufferTooSmall))?;
w.u16(length)?;
}
w.position()
};
debug_assert_eq!(len, Frame::header_len(ack.is_some(), beginning));
self.tx_sequence = self.tx_sequence.wrapping_add(1);
if let Some(ack) = ack {
self.rx_acked = ack;
self.pending_ack = None;
self.send_ack_at = None;
}
if self.ack_deadline.is_none() {
self.ack_deadline = Some(now.saturating_add(ACK_TIMEOUT));
}
Ok(len)
}
pub fn receive(&mut self, bytes: &[u8], now: Instant) -> Result<Received> {
self.guard()?;
let result = self.receive_inner(bytes, now);
self.fail(result)
}
fn receive_inner(&mut self, bytes: &[u8], now: Instant) -> Result<Received> {
let frame = Frame::decode(bytes)?;
if frame.sequence != self.rx_sequence.wrapping_add(1) {
bail!(BtpSequence)
}
self.rx_sequence = frame.sequence;
if self.rx_sequence.wrapping_sub(self.rx_acked) > self.max_window {
bail!(BtpSequence)
}
self.pending_ack = Some(frame.sequence);
if self.send_ack_at.is_none() {
self.send_ack_at = Some(now.saturating_add(SEND_ACK_TIMEOUT));
}
if let Some(acked) = frame.ack {
let outstanding = self.in_flight();
let newly = acked.wrapping_sub(self.tx_acked);
if newly == 0 || newly > outstanding {
bail!(BtpSequence)
}
self.tx_acked = acked;
self.ack_deadline = if newly == outstanding {
None
} else {
Some(now.saturating_add(ACK_TIMEOUT))
};
}
if frame.payload.is_empty() && !frame.flags.contains(Flags::BEGINNING) {
return Ok(Received::Ack);
}
self.last_data = now;
if frame.flags.contains(Flags::BEGINNING) {
if self.rx_expected.is_some() {
bail!(BtpMalformed)
}
let Some(length) = frame.message_length else {
bail!(BtpMalformed)
};
if usize::from(length) > SDU {
bail!(BufferTooSmall)
}
self.rx_expected = Some(length);
self.rx_len = 0;
} else if self.rx_expected.is_none() {
bail!(BtpMalformed)
}
let end = self
.rx_len
.checked_add(frame.payload.len())
.ok_or(Error::new(ErrorCode::BufferTooSmall))?;
let Some(slot) = self.rx.get_mut(self.rx_len..end) else {
bail!(BufferTooSmall)
};
slot.copy_from_slice(frame.payload);
self.rx_len = end;
if !frame.flags.contains(Flags::ENDING) {
return Ok(Received::Partial);
}
let Some(expected) = self.rx_expected.take() else {
bail!(BtpMalformed)
};
if usize::from(expected) != self.rx_len {
bail!(BtpMalformed)
}
Ok(Received::Message)
}
#[must_use]
pub fn message(&self) -> &[u8] {
self.rx.get(..self.rx_len).unwrap_or(&[])
}
pub const fn take_message(&mut self) {
self.rx_len = 0;
self.rx_expected = None;
}
pub fn poll_timeout(&mut self, now: Instant) -> Result<()> {
self.guard()?;
if self.ack_deadline.is_some_and(|deadline| now >= deadline) {
self.closed = Some(ErrorCode::BtpTimeout);
bail!(BtpTimeout)
}
Ok(())
}
#[must_use]
pub fn is_idle(&self, now: Instant) -> bool {
now.saturating_duration_since(self.last_data) >= CONN_IDLE_TIMEOUT
}
#[must_use]
pub fn wake_at(&self) -> Option<Instant> {
match (self.send_ack_at, self.ack_deadline) {
(Some(a), Some(b)) => Some(if a <= b { a } else { b }),
(Some(a), None) => Some(a),
(None, b) => b,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn at(secs: u64) -> Instant {
Instant::from_micros(secs.saturating_mul(1_000_000))
}
fn agreed() -> HandshakeResponse {
HandshakeResponse {
version: VERSION,
att_mtu: 247,
window: 6,
}
}
fn pair() -> (Session<1280>, Session<1280>) {
(
Session::new(Role::Client, &agreed().params(), at(0)),
Session::new(Role::Server, &agreed().params(), at(0)),
)
}
#[test]
fn the_handshake_request_matches_table_31() {
let mut request = HandshakeRequest::new(247, 6);
request.versions[1] = 3;
let mut buf = [0u8; 16];
assert_eq!(request.encode(&mut buf).expect("encode"), 9);
assert_eq!(buf[0], 0x65, "H | M | E | B");
assert_eq!(buf[1], 0x6C, "the only Management Opcode BTP defines");
assert_eq!(buf[2], 0x34, "Ver[0] = 4 low, Ver[1] = 3 high");
assert_eq!(&buf[3..6], &[0, 0, 0], "unused version slots are zero");
assert_eq!(&buf[6..8], &[247, 0], "ATT_MTU little-endian");
assert_eq!(buf[8], 6);
assert_eq!(HandshakeRequest::decode(&buf).expect("decode"), request);
}
#[test]
fn the_handshake_response_matches_table_32() {
let mut buf = [0u8; 16];
assert_eq!(agreed().encode(&mut buf).expect("encode"), 6);
assert_eq!(&buf[..3], &[0x65, 0x6C, 4], "version in the low nibble");
assert_eq!(&buf[3..5], &[247, 0]);
assert_eq!(buf[5], 6);
assert_eq!(HandshakeResponse::decode(&buf).expect("decode"), agreed());
}
#[test]
fn negotiation_takes_the_lower_of_each() {
let bigger = HandshakeRequest::new(512, 10);
let result = negotiate(&bigger, 247, 6).expect("negotiate");
assert_eq!(result.att_mtu, 247, "the server's is smaller");
assert_eq!(result.window, 6);
let none = HandshakeRequest::new(0, 4);
assert_eq!(negotiate(&none, 247, 6).expect("ok").att_mtu, 247);
assert_eq!(negotiate(&none, 247, 6).expect("ok").window, 4);
let mut future = HandshakeRequest::new(247, 4);
future.versions[0] = 9;
assert_eq!(
negotiate(&future, 247, 6).map_err(|e| e.code()),
Err(ErrorCode::UnsupportedVersion)
);
}
#[test]
fn the_segment_size_is_capped_at_the_characteristic_length() {
assert_eq!(agreed().segment_size(), 244);
let huge = HandshakeResponse {
att_mtu: 517,
..agreed()
};
assert_eq!(huge.segment_size(), 244);
let minimum = HandshakeResponse {
att_mtu: MIN_ATT_MTU,
..agreed()
};
assert_eq!(minimum.segment_size(), 20, "the BLE 4.0 floor");
}
#[test]
fn the_two_ends_start_differently_because_the_response_occupies_a_slot() {
let (client, server) = pair();
assert_eq!(client.tx_sequence, 0);
assert_eq!(server.tx_sequence, 1, "the response was an implied zero");
assert_eq!(client.remote_window(), 6);
assert_eq!(
server.remote_window(),
5,
"the response already took a slot"
);
assert!(
client.owes_ack(),
"the client acknowledges the response's implied sequence zero"
);
assert_eq!(
client.own_window_free(),
5,
"and that slot is its own, used"
);
assert_eq!(server.own_window_free(), 6);
}
#[test]
fn a_message_larger_than_a_segment_is_split_and_put_back_together() {
let (mut client, mut server) = pair();
let sdu: heapless::Vec<u8, 600> = (0..600u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut segments = 0;
let mut wire = [0u8; 256];
while let Some(n) = client.poll_send(at(0), &mut wire).expect("send") {
segments += 1;
assert!(segments < 100, "segmentation must terminate");
if server.receive(&wire[..n], at(0)).expect("receive") == Received::Message {
break;
}
}
assert!(
segments > 1,
"600 octets does not fit one 244-octet segment"
);
assert_eq!(server.message(), sdu.as_slice());
}
#[test]
fn a_full_message_exchange_runs_in_both_directions() {
let (mut client, mut server) = pair();
let request: heapless::Vec<u8, 700> = (0..700u16).map(|i| (i * 7) as u8).collect();
let response: heapless::Vec<u8, 500> = (0..500u16).map(|i| (i * 3) as u8).collect();
let mut wire = [0u8; 256];
client.send(&request).expect("queue");
while let Some(n) = client.poll_send(at(0), &mut wire).expect("send") {
server.receive(&wire[..n], at(0)).expect("receive");
}
assert_eq!(server.message(), request.as_slice());
server.take_message();
server.send(&response).expect("queue");
while let Some(n) = server.poll_send(at(1), &mut wire).expect("send") {
client.receive(&wire[..n], at(1)).expect("receive");
}
assert_eq!(client.message(), response.as_slice());
assert_eq!(client.in_flight(), 0);
client
.poll_timeout(at(1000))
.expect("no packet outstanding");
}
#[test]
fn a_whole_sdu_that_fits_one_segment_sets_both_beginning_and_ending() {
let (mut client, _) = pair();
client.send(b"short").expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
let frame = Frame::decode(&wire[..n]).expect("decode");
assert!(frame.flags.contains(Flags::BEGINNING | Flags::ENDING));
assert!(!frame.flags.contains(Flags::CONTINUING));
assert_eq!(frame.message_length, Some(5));
assert_eq!(frame.payload, b"short");
assert!(!client.is_sending());
}
#[test]
fn every_segment_after_the_first_carries_the_continuing_bit() {
let (mut client, _) = pair();
let sdu: heapless::Vec<u8, 600> = (0..600u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 256];
let mut first = true;
let mut saw_ending = false;
while let Some(n) = client.poll_send(at(0), &mut wire).expect("send") {
let frame = Frame::decode(&wire[..n]).expect("decode");
assert_eq!(frame.flags.contains(Flags::CONTINUING), !first);
assert_eq!(frame.flags.contains(Flags::BEGINNING), first);
saw_ending = frame.flags.contains(Flags::ENDING);
first = false;
}
assert!(saw_ending, "the last segment ends the SDU");
}
#[test]
fn a_sequence_number_out_of_order_closes_the_session() {
let (mut client, mut server) = pair();
client.send(b"one").expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
server.receive(&wire[..n], at(0)).expect("the first packet");
let mut tampered = wire;
let sequence_at = usize::from(Frame::decode(&wire[..n]).expect("decode").ack.is_some()) + 1;
tampered[sequence_at] = 5;
assert_eq!(
server.receive(&tampered[..n], at(0)).map_err(|e| e.code()),
Err(ErrorCode::BtpSequence)
);
}
#[test]
fn an_acknowledgement_for_a_packet_never_sent_closes_the_session() {
let (_, mut server) = pair();
let frame = [
(Flags::BEGINNING | Flags::ENDING | Flags::ACK).bits(),
9,
0,
1,
0,
0xAA,
];
assert_eq!(
server.receive(&frame, at(0)).map_err(|e| e.code()),
Err(ErrorCode::BtpSequence)
);
}
#[test]
fn one_acknowledgement_clears_every_slot_before_it() {
let (mut client, _) = pair();
let sdu: heapless::Vec<u8, 900> = (0..900u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 256];
while client.poll_send(at(0), &mut wire).expect("send").is_some() {}
assert!(client.in_flight() >= 3, "several segments are outstanding");
assert!(client.remote_window() < 6);
let last = client.tx_sequence.wrapping_sub(1);
let ack = [Flags::ACK.bits(), last, 1];
client.receive(&ack, at(1)).expect("the acknowledgement");
assert_eq!(client.in_flight(), 0);
assert_eq!(client.remote_window(), 6, "the whole window is back");
assert!(
client.wake_at().is_some(),
"the send-acknowledgement timer is now running for the ack packet itself"
);
}
#[test]
fn an_ending_segment_with_no_beginning_is_refused() {
let (_, mut server) = pair();
let frame = [Flags::ENDING.bits(), 0, 0xAA, 0xBB];
assert_eq!(
server.receive(&frame, at(0)).map_err(|e| e.code()),
Err(ErrorCode::BtpMalformed)
);
}
#[test]
fn a_second_beginning_while_an_sdu_is_in_progress_is_refused() {
let (mut client, mut server) = pair();
let sdu: heapless::Vec<u8, 600> = (0..600u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
assert_eq!(
server.receive(&wire[..n], at(0)).expect("first"),
Received::Partial
);
let frame = [
(Flags::BEGINNING | Flags::ENDING).bits(),
server.rx_sequence.wrapping_add(1),
1,
0,
0xAA,
];
assert_eq!(
server.receive(&frame, at(0)).map_err(|e| e.code()),
Err(ErrorCode::BtpMalformed)
);
}
#[test]
fn a_reassembly_that_does_not_match_its_declared_length_is_refused() {
let (_, mut server) = pair();
let frame = [
(Flags::BEGINNING | Flags::ENDING).bits(),
0,
9,
0,
0xAA,
0xBB,
];
assert_eq!(
server.receive(&frame, at(0)).map_err(|e| e.code()),
Err(ErrorCode::BtpMalformed)
);
}
#[test]
fn a_message_larger_than_the_reassembly_buffer_is_refused_at_its_first_segment() {
let mut small = Session::<64>::new(Role::Server, &agreed().params(), at(0));
let frame = [Flags::BEGINNING.bits(), 0, 0x00, 0x02, 0xAA];
assert_eq!(
small.receive(&frame, at(0)).map_err(|e| e.code()),
Err(ErrorCode::BufferTooSmall)
);
}
#[test]
fn the_window_reserves_its_last_slot_for_a_packet_that_carries_an_ack() {
let (mut client, _) = pair();
client.tx_sequence = 5;
client.tx_acked = 255;
assert_eq!(client.remote_window(), 1);
client.pending_ack = None;
assert!(!client.can_send(), "one slot and nothing to acknowledge");
client.pending_ack = Some(3);
assert!(
client.can_send(),
"the last slot is for a packet that reopens the other side"
);
client.tx_sequence = 6;
assert_eq!(client.remote_window(), 0);
assert!(!client.can_send(), "a closed window sends nothing at all");
}
#[test]
fn a_closed_window_stops_segmentation_and_resuming_it_restarts_it() {
let narrow = HandshakeResponse {
window: 3,
..agreed()
};
let mut client = Session::<1280>::new(Role::Client, &narrow.params(), at(0));
let sdu: heapless::Vec<u8, 1200> = (0..1200u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 256];
let mut sent = 0;
while client.poll_send(at(0), &mut wire).expect("send").is_some() {
sent += 1;
}
assert_eq!(sent, 2);
assert_eq!(client.remote_window(), 1);
assert!(!client.can_send());
assert!(client.is_sending(), "the SDU is not finished");
let ack = [Flags::ACK.bits(), client.tx_sequence.wrapping_sub(1), 1];
client.receive(&ack, at(1)).expect("ack");
assert!(client.poll_send(at(1), &mut wire).expect("send").is_some());
}
#[test]
fn a_second_sdu_while_one_is_in_flight_is_refused() {
let (mut client, _) = pair();
let big: heapless::Vec<u8, 600> = (0..600u16).map(|i| i as u8).collect();
client.send(&big).expect("queue");
let mut wire = [0u8; 256];
client.poll_send(at(0), &mut wire).expect("send");
assert!(client.is_sending());
assert_eq!(
client.send(b"jump the queue").map_err(|e| e.code()),
Err(ErrorCode::Busy)
);
}
#[test]
fn a_handshake_packet_is_not_decoded_as_data() {
let mut buf = [0u8; 16];
HandshakeRequest::new(247, 6)
.encode(&mut buf)
.expect("encode");
assert_eq!(
Frame::decode(&buf).map_err(|e| e.code()),
Err(ErrorCode::BtpMalformed)
);
}
#[test]
fn a_pending_acknowledgement_rides_on_the_next_segment() {
let (mut client, mut server) = pair();
client.send(b"hello").expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
server.receive(&wire[..n], at(0)).expect("receive");
assert!(server.owes_ack());
server.send(b"reply").expect("queue");
let n = server
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
let frame = Frame::decode(&wire[..n]).expect("decode");
assert_eq!(frame.ack, Some(0), "the client's first packet");
assert!(
!server.owes_ack(),
"and the send-acknowledgement timer stops"
);
}
#[test]
fn an_idle_peer_sends_its_acknowledgement_alone_once_the_timer_fires() {
let (mut client, mut server) = pair();
client.send(b"hello").expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
server.receive(&wire[..n], at(0)).expect("receive");
assert!(
server.poll_send(at(0), &mut wire).expect("send").is_none(),
"nothing is due yet"
);
let due = server
.wake_at()
.expect("the send-acknowledgement timer runs");
let n = server
.poll_send(due, &mut wire)
.expect("send")
.expect("a stand-alone ack");
let frame = Frame::decode(&wire[..n]).expect("decode");
assert!(frame.payload.is_empty(), "no segment rides with it");
assert_eq!(frame.ack, Some(0));
assert!(
frame
.flags
.intersection(Flags::BEGINNING | Flags::CONTINUING | Flags::ENDING)
.is_empty(),
"a stand-alone ack belongs to no SDU"
);
assert_eq!(
client.receive(&wire[..n], due).expect("receive"),
Received::Ack
);
assert!(
client.owes_ack(),
"stand-alone acks are themselves acknowledged"
);
}
#[test]
fn a_nearly_full_receive_window_forces_the_acknowledgement_out_early() {
let (mut client, mut server) = pair();
let sdu: heapless::Vec<u8, 1000> = (0..1000u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 256];
let mut forced = None;
while let Some(n) = client.poll_send(at(0), &mut wire).expect("send") {
server.receive(&wire[..n], at(0)).expect("receive");
if server.own_window_free() <= 2 {
forced = server.poll_send(at(0), &mut wire).expect("send");
break;
}
}
let n = forced.expect("the ack went out early");
assert!(
Frame::decode(&wire[..n])
.expect("decode")
.payload
.is_empty(),
"stand-alone, because the server has nothing to say yet"
);
}
#[test]
fn an_unanswered_packet_eventually_closes_the_session() {
let (mut client, _) = pair();
client.send(b"hello").expect("queue");
let mut wire = [0u8; 256];
client.poll_send(at(0), &mut wire).expect("send");
client
.poll_timeout(at(14))
.expect("still within the timeout");
assert_eq!(
client.poll_timeout(at(15)).map_err(|e| e.code()),
Err(ErrorCode::BtpTimeout)
);
}
#[test]
fn the_server_starts_its_timer_when_it_sends_the_handshake_response() {
let (_, mut server) = pair();
server.poll_timeout(at(14)).expect("still running");
assert_eq!(
server.poll_timeout(at(15)).map_err(|e| e.code()),
Err(ErrorCode::BtpTimeout)
);
}
#[test]
fn a_session_that_closes_stays_closed() {
let (mut client, mut server) = pair();
client.send(b"hello").expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
server.receive(&wire[..n], at(0)).expect("the first packet");
let mut tampered = wire;
let sequence_at = usize::from(Frame::decode(&wire[..n]).expect("decode").ack.is_some()) + 1;
tampered[sequence_at] = 200;
assert_eq!(
server.receive(&tampered[..n], at(0)).map_err(|e| e.code()),
Err(ErrorCode::BtpSequence)
);
assert!(server.is_closed());
assert_eq!(server.close_reason(), Some(ErrorCode::BtpSequence));
for code in [
server.receive(&wire[..n], at(1)).err().map(|e| e.code()),
server.poll_send(at(1), &mut wire).err().map(|e| e.code()),
server.send(b"reply").err().map(|e| e.code()),
server.poll_timeout(at(1)).err().map(|e| e.code()),
] {
assert_eq!(code, Some(ErrorCode::BtpSequence));
}
}
#[test]
fn an_acknowledgement_for_all_but_the_newest_packet_restarts_the_timer() {
let (mut client, _) = pair();
let sdu: heapless::Vec<u8, 900> = (0..900u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 256];
while client.poll_send(at(0), &mut wire).expect("send").is_some() {}
let outstanding = client.in_flight();
assert!(outstanding >= 3);
let partial = client.tx_sequence.wrapping_sub(2);
client
.receive(&[Flags::ACK.bits(), partial, 1], at(3))
.expect("ack");
assert_eq!(client.in_flight(), 1);
client
.poll_timeout(at(17))
.expect("the timer restarted at t = 3");
assert_eq!(
client.poll_timeout(at(18)).map_err(|e| e.code()),
Err(ErrorCode::BtpTimeout)
);
}
#[test]
fn idleness_is_measured_in_data_not_acknowledgements() {
let (mut client, mut server) = pair();
client.send(b"hello").expect("queue");
let mut wire = [0u8; 256];
let n = client
.poll_send(at(0), &mut wire)
.expect("send")
.expect("a packet");
server.receive(&wire[..n], at(0)).expect("receive");
assert!(!client.is_idle(at(29)));
let n = server
.poll_send(at(20), &mut wire)
.expect("send")
.expect("an ack");
client.receive(&wire[..n], at(20)).expect("receive");
assert!(
client.is_idle(at(31)),
"thirty seconds since the last segment"
);
}
#[test]
fn the_smallest_ble_mtu_still_carries_a_matter_message() {
let tiny = HandshakeResponse {
att_mtu: MIN_ATT_MTU,
..agreed()
};
let mut client = Session::<1280>::new(Role::Client, &tiny.params(), at(0));
let mut server = Session::<1280>::new(Role::Server, &tiny.params(), at(0));
let sdu: heapless::Vec<u8, 1280> = (0..1280u16).map(|i| i as u8).collect();
client.send(&sdu).expect("queue");
let mut wire = [0u8; 32];
let mut guard = 0;
loop {
guard += 1;
assert!(guard < 1000, "the transfer must terminate");
if let Some(n) = client.poll_send(at(0), &mut wire).expect("send") {
assert!(n <= 20, "a segment never exceeds ATT_MTU - 3");
if server.receive(&wire[..n], at(0)).expect("receive") == Received::Message {
break;
}
} else {
let Some(n) = server.poll_send(at(0), &mut wire).expect("send") else {
panic!("neither peer can make progress")
};
client.receive(&wire[..n], at(0)).expect("ack");
}
}
assert_eq!(server.message(), sdu.as_slice());
}
}