use crate::bytes::Cursor;
use crate::error::{ErrorCode, Result, bail};
pub use super::btp::{
ACK_TIMEOUT, CONN_IDLE_TIMEOUT, CONN_RSP_TIMEOUT, Frame, HANDSHAKE_FLAGS, MAX_WINDOW,
OPCODE_HANDSHAKE, Received, Role, Session, SessionParams,
};
pub const VERSION: u8 = 4;
pub const DEFAULT_SSI_LENGTH: u16 = 350;
pub const HEADER_MAX: u16 = 5;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HandshakeRequest {
pub versions: [u8; 8],
pub ssi_length: u16,
pub window: u8,
}
impl HandshakeRequest {
pub const LEN: usize = 9;
#[must_use]
pub const fn new(ssi_length: u16, window: u8) -> Self {
let mut versions = [0u8; 8];
versions[0] = VERSION;
Self {
versions,
ssi_length,
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.ssi_length)?;
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,
ssi_length: 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 ssi_length: 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.ssi_length)?;
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,
ssi_length: 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 length = if self.ssi_length == 0 {
DEFAULT_SSI_LENGTH
} else {
self.ssi_length
};
length.saturating_sub(HEADER_MAX) as usize
}
}
pub fn negotiate(
request: &HandshakeRequest,
own_ssi_length: u16,
own_window: u8,
) -> Result<HandshakeResponse> {
let Some(version) = request.best_version() else {
bail!(UnsupportedVersion)
};
let own = if own_ssi_length == 0 {
DEFAULT_SSI_LENGTH
} else {
own_ssi_length
};
let requested = if request.ssi_length == 0 {
own
} else {
request.ssi_length.min(own)
};
let window = request.window.min(own_window);
if window == 0 {
bail!(InvalidArgument)
}
Ok(HandshakeResponse {
version,
ssi_length: requested.max(HEADER_MAX.saturating_add(1)),
window,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_handshake_is_btps_shape_with_a_different_middle() {
let request = HandshakeRequest::new(DEFAULT_SSI_LENGTH, 4);
let mut buf = [0u8; 16];
let n = request.encode(&mut buf).expect("encode");
assert_eq!(n, HandshakeRequest::LEN);
assert_eq!(
&buf[..n],
&[0x65, 0x6C, 0x04, 0x00, 0x00, 0x00, 0x5E, 0x01, 0x04]
);
assert_eq!(
HandshakeRequest::decode(&buf[..n]).expect("decode"),
request
);
}
#[test]
fn a_response_round_trips() {
let response = HandshakeResponse {
version: VERSION,
ssi_length: 350,
window: 4,
};
let mut buf = [0u8; 16];
let n = response.encode(&mut buf).expect("encode");
assert_eq!(n, HandshakeResponse::LEN);
assert_eq!(&buf[..n], &[0x65, 0x6C, 0x04, 0x5E, 0x01, 0x04]);
assert_eq!(
HandshakeResponse::decode(&buf[..n]).expect("decode"),
response
);
}
#[test]
fn the_segment_is_the_frame_less_the_paftp_header() {
let response = HandshakeResponse {
version: VERSION,
ssi_length: 350,
window: 4,
};
assert_eq!(response.segment_size(), 345);
assert_eq!(response.params().window, 4);
let unknown = HandshakeResponse {
ssi_length: 0,
..response
};
assert_eq!(unknown.segment_size(), 345);
}
#[test]
fn negotiation_takes_both_minima() {
let request = HandshakeRequest::new(350, 6);
let response = negotiate(&request, 256, 4).expect("negotiate");
assert_eq!(response.ssi_length, 256, "the smaller frame");
assert_eq!(response.window, 4, "the smaller window");
assert_eq!(response.version, VERSION);
}
#[test]
fn a_version_nobody_shares_closes_the_connection() {
let mut request = HandshakeRequest::new(350, 4);
request.versions = [9, 8, 0, 0, 0, 0, 0, 0];
assert!(negotiate(&request, 350, 4).is_err());
}
}