pub use crate::frame::FrameScan;
pub const REPORT_ID_OUT: u8 = 0x03;
pub const REPORT_ID_IN: u8 = 0x04;
pub const REPORT_SIZE: usize = 256;
pub const REPORT_PAYLOAD: usize = REPORT_SIZE - 1;
pub const MAX_MESSAGE_LEN: usize = 1024 * 1024;
pub const HANDSHAKE_BODY: [u8; 4] = [0xAD, 0x10, 0xA7, 0xB0];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Packet {
pub length: u32,
pub payload: Vec<u8>,
}
impl Packet {
#[must_use]
pub fn new(payload: Vec<u8>) -> Self {
Packet {
length: payload.len() as u32,
payload,
}
}
#[must_use]
pub fn to_bytes(&self) -> Vec<u8> {
let mut framed = Vec::with_capacity(4 + self.payload.len());
framed.extend_from_slice(&self.length.to_le_bytes());
framed.extend_from_slice(&self.payload);
let n_reports = framed.len().div_ceil(REPORT_PAYLOAD).max(1);
let mut out = vec![0u8; n_reports * REPORT_SIZE];
for (i, chunk) in framed.chunks(REPORT_PAYLOAD).enumerate() {
let base = i * REPORT_SIZE;
out[base] = REPORT_ID_OUT;
out[base + 1..=base + chunk.len()].copy_from_slice(chunk);
}
out
}
#[must_use]
pub fn from_bytes(buf: &[u8]) -> Option<(Self, usize)> {
let (body_len, n_reports) = match scan_frame(buf) {
FrameScan::Complete { len } => (frame_len_unchecked(buf), len / REPORT_SIZE),
FrameScan::Incomplete | FrameScan::Desync => return None,
};
let mut framed = Vec::with_capacity(n_reports * REPORT_PAYLOAD);
for i in 0..n_reports {
let base = i * REPORT_SIZE;
framed.extend_from_slice(&buf[base + 1..base + REPORT_SIZE]);
}
let body = framed[4..4 + body_len].to_vec();
Some((
Packet {
length: body_len as u32,
payload: body,
},
n_reports * REPORT_SIZE,
))
}
}
fn frame_len_unchecked(buf: &[u8]) -> usize {
u32::from_le_bytes([buf[1], buf[2], buf[3], buf[4]]) as usize
}
#[must_use]
pub fn scan_frame(buf: &[u8]) -> FrameScan {
if buf.len() < REPORT_SIZE {
return FrameScan::Incomplete;
}
let body_len = frame_len_unchecked(buf);
if body_len == 0 || body_len > MAX_MESSAGE_LEN {
return FrameScan::Desync;
}
let n_reports = (4 + body_len).div_ceil(REPORT_PAYLOAD);
let total_raw = n_reports * REPORT_SIZE;
if buf.len() < total_raw {
return FrameScan::Incomplete;
}
FrameScan::Complete { len: total_raw }
}
#[must_use]
pub fn frame_payload(buf: &[u8]) -> Option<Vec<u8>> {
Packet::from_bytes(buf).map(|(p, _)| p.payload)
}
#[must_use]
pub fn handshake_bytes() -> Vec<u8> {
Packet::new(HANDSHAKE_BODY.to_vec()).to_bytes()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn packet_roundtrip_single_report() {
let payload = vec![0x02, 0xDE, 0xAD, 0xBE, 0xEF];
let bytes = Packet::new(payload.clone()).to_bytes();
assert_eq!(bytes.len(), REPORT_SIZE);
let (parsed, consumed) = Packet::from_bytes(&bytes).unwrap();
assert_eq!(consumed, bytes.len());
assert_eq!(parsed.payload, payload);
assert_eq!(parsed.length as usize, payload.len());
}
#[test]
fn to_bytes_layout_is_len_payload_no_magic() {
let bytes = Packet::new(vec![0xAA, 0xBB]).to_bytes();
assert_eq!(bytes[0], REPORT_ID_OUT); assert_eq!(&bytes[1..5], &2u32.to_le_bytes()); assert_eq!(&bytes[5..7], &[0xAA, 0xBB]); assert!(bytes[7..].iter().all(|&b| b == 0)); }
#[test]
fn handshake_matches_known_bytes() {
let bytes = handshake_bytes();
assert_eq!(bytes.len(), REPORT_SIZE);
assert_eq!(bytes[0], REPORT_ID_OUT);
assert_eq!(
&bytes[1..9],
&[0x04, 0x00, 0x00, 0x00, 0xAD, 0x10, 0xA7, 0xB0]
);
assert!(bytes[9..].iter().all(|&b| b == 0));
}
#[test]
fn packet_roundtrip_multi_report() {
let payload: Vec<u8> = (0..600u32).map(|i| (i % 251) as u8).collect();
let bytes = Packet::new(payload.clone()).to_bytes();
assert_eq!(bytes.len(), 3 * REPORT_SIZE);
let (parsed, consumed) = Packet::from_bytes(&bytes).unwrap();
assert_eq!(consumed, 3 * REPORT_SIZE);
assert_eq!(parsed.payload, payload);
assert_eq!(frame_payload(&bytes), Some(payload));
}
#[test]
fn scan_frame_complete_incomplete_desync() {
let bytes = Packet::new(vec![1, 2, 3]).to_bytes();
assert_eq!(scan_frame(&bytes), FrameScan::Complete { len: REPORT_SIZE });
assert_eq!(scan_frame(&bytes[..REPORT_SIZE - 1]), FrameScan::Incomplete);
assert_eq!(scan_frame(&[]), FrameScan::Incomplete);
let big = Packet::new(vec![7u8; 600]).to_bytes();
assert_eq!(scan_frame(&big[..2 * REPORT_SIZE]), FrameScan::Incomplete);
let zero = [0u8; REPORT_SIZE];
assert_eq!(scan_frame(&zero), FrameScan::Desync);
let mut huge = [0u8; REPORT_SIZE];
huge[1..5].copy_from_slice(&(MAX_MESSAGE_LEN as u32 + 1).to_le_bytes());
assert_eq!(scan_frame(&huge), FrameScan::Desync);
}
#[test]
fn report_aligned_stops_at_first_message_boundary() {
let first = Packet::new(vec![0x02, 0xAA]).to_bytes();
let first_len = first.len();
let mut two = first;
two.extend_from_slice(&Packet::new(vec![0x02, 0xBB, 0xCC]).to_bytes());
assert_eq!(scan_frame(&two), FrameScan::Complete { len: first_len });
assert_eq!(frame_payload(&two), Some(vec![0x02, 0xAA]));
let (_, consumed) = Packet::from_bytes(&two).unwrap();
assert_eq!(
frame_payload(&two[consumed..]),
Some(vec![0x02, 0xBB, 0xCC])
);
}
#[test]
fn from_bytes_ignores_report_id_so_in_stream_decodes() {
let mut bytes = Packet::new(vec![0x02, 0x11, 0x22]).to_bytes();
bytes[0] = REPORT_ID_IN;
assert_eq!(frame_payload(&bytes), Some(vec![0x02, 0x11, 0x22]));
}
}