use crate::crc16;
use std::collections::HashMap;
use std::time::{Duration, Instant};
pub const CC: u8 = 0x55;
pub const FIRST_SEGMENT: u8 = 0xc0;
pub const SEGMENT_COMPLETE: u8 = 0xe8;
pub const SEGMENT_REQUEST: u8 = 0xc8;
pub const SEGMENT_WAIT: u8 = 0xf0;
pub const SUBSEQUENT_SEGMENT: u8 = 0xe0;
pub const MAX_DATAGRAM: usize = 0x7ff;
pub const DEFAULT_SEGMENT: usize = 39;
pub const SEGMENT_TIMEOUT: Duration = Duration::from_secs(1);
pub const MAX_SESSIONS: usize = 16;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Segment {
First {
size: u16,
session: u8,
data: Vec<u8>,
},
Subsequent {
size: u16,
session: u8,
offset: u16,
data: Vec<u8>,
},
Request {
session: u8,
offset: u16,
},
Complete {
session: u8,
},
Wait {
pending: u8,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
pub enum Error {
#[error("malformed transport service frame")]
Malformed,
#[error("transport service CRC mismatch")]
Crc,
#[error("segment outside the datagram")]
OutOfBounds,
}
pub fn parse(frame: &[u8]) -> Result<Segment, Error> {
if frame.len() < 2 || frame[0] != CC {
return Err(Error::Malformed);
}
let cmd = frame[1] & 0xf8;
let hi = u16::from(frame[1] & 0x07);
match cmd {
FIRST_SEGMENT | SUBSEQUENT_SEGMENT => {
let header = if cmd == FIRST_SEGMENT { 4 } else { 5 };
if frame.len() < header + 2 {
return Err(Error::Malformed);
}
let (body, crc) = frame.split_at(frame.len() - 2);
if crc16::checksum(body) != u16::from_be_bytes([crc[0], crc[1]]) {
return Err(Error::Crc);
}
let size = (hi << 8) | u16::from(frame[2]);
let session = frame[3] >> 4;
let ext = frame[3] & 0x08 != 0;
let mut at = header;
if ext {
let n = usize::from(*body.get(at).ok_or(Error::Malformed)?);
at += 1 + n;
if at > body.len() {
return Err(Error::Malformed);
}
}
let data = body[at..].to_vec();
if cmd == FIRST_SEGMENT {
Ok(Segment::First {
size,
session,
data,
})
} else {
let offset = (u16::from(frame[3] & 0x07) << 8) | u16::from(frame[4]);
Ok(Segment::Subsequent {
size,
session,
offset,
data,
})
}
}
SEGMENT_REQUEST => {
if frame.len() < 4 {
return Err(Error::Malformed);
}
Ok(Segment::Request {
session: frame[2] >> 4,
offset: (u16::from(frame[2] & 0x07) << 8) | u16::from(frame[3]),
})
}
SEGMENT_COMPLETE => Ok(Segment::Complete {
session: *frame.get(2).ok_or(Error::Malformed)? >> 4,
}),
SEGMENT_WAIT => Ok(Segment::Wait {
pending: *frame.get(2).ok_or(Error::Malformed)?,
}),
_ => Err(Error::Malformed),
}
}
fn with_crc(mut v: Vec<u8>) -> Vec<u8> {
let c = crc16::checksum(&v);
v.extend_from_slice(&c.to_be_bytes());
v
}
pub fn segment(datagram: &[u8], session: u8, segment: usize) -> Vec<Vec<u8>> {
assert!(datagram.len() <= MAX_DATAGRAM, "datagram too long");
let segment = segment.max(1);
let size = datagram.len() as u16;
let mut out = Vec::new();
for (i, chunk) in datagram.chunks(segment).enumerate() {
let offset = (i * segment) as u16;
let mut v = vec![CC];
if i == 0 {
v.push(FIRST_SEGMENT | ((size >> 8) as u8 & 0x07));
v.push(size as u8);
v.push((session & 0x0f) << 4);
} else {
v.push(SUBSEQUENT_SEGMENT | ((size >> 8) as u8 & 0x07));
v.push(size as u8);
v.push(((session & 0x0f) << 4) | ((offset >> 8) as u8 & 0x07));
v.push(offset as u8);
}
v.extend_from_slice(chunk);
out.push(with_crc(v));
}
out
}
pub fn complete(session: u8) -> Vec<u8> {
vec![CC, SEGMENT_COMPLETE, (session & 0x0f) << 4]
}
pub fn request(session: u8, offset: u16) -> Vec<u8> {
vec![
CC,
SEGMENT_REQUEST,
((session & 0x0f) << 4) | ((offset >> 8) as u8 & 0x07),
offset as u8,
]
}
struct Partial {
size: usize,
data: Vec<u8>,
have: Vec<bool>,
last: Instant,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Reassembly {
Pending,
Done(Vec<u8>),
}
#[derive(Default)]
pub struct Reassembler {
sessions: HashMap<(u16, u8), Partial>,
}
impl std::fmt::Debug for Reassembler {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Reassembler({} sessions)", self.sessions.len())
}
}
impl Reassembler {
pub fn push(&mut self, peer: u16, seg: Segment) -> Result<Reassembly, Error> {
let now = Instant::now();
self.sessions
.retain(|_, p| now.duration_since(p.last) < SEGMENT_TIMEOUT * 4);
let (size, session, offset, data) = match seg {
Segment::First {
size,
session,
data,
} => {
if self.sessions.len() >= MAX_SESSIONS {
if let Some(k) = self
.sessions
.iter()
.min_by_key(|(_, p)| p.last)
.map(|(k, _)| *k)
{
self.sessions.remove(&k);
}
}
let size = usize::from(size);
self.sessions.insert(
(peer, session),
Partial {
size,
data: vec![0; size],
have: vec![false; size],
last: now,
},
);
(size, session, 0usize, data)
}
Segment::Subsequent {
size,
session,
offset,
data,
} => (usize::from(size), session, usize::from(offset), data),
_ => return Err(Error::Malformed),
};
let p = self
.sessions
.get_mut(&(peer, session))
.ok_or(Error::OutOfBounds)?;
if p.size != size || offset + data.len() > p.size {
self.sessions.remove(&(peer, session));
return Err(Error::OutOfBounds);
}
p.data[offset..offset + data.len()].copy_from_slice(&data);
p.have[offset..offset + data.len()]
.iter_mut()
.for_each(|h| *h = true);
p.last = now;
if p.have.iter().all(|&h| h) {
let p = self.sessions.remove(&(peer, session)).expect("present");
return Ok(Reassembly::Done(p.data));
}
Ok(Reassembly::Pending)
}
pub fn missing(&self, peer: u16, session: u8) -> Option<u16> {
let p = self.sessions.get(&(peer, session))?;
p.have.iter().position(|h| !h).map(|i| i as u16)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn segment_and_reassemble() {
let datagram: Vec<u8> = (0..100u8).collect();
let frames = segment(&datagram, 3, 39);
assert_eq!(frames.len(), 3);
let mut r = Reassembler::default();
assert_eq!(
r.push(7, parse(&frames[0]).unwrap()).unwrap(),
Reassembly::Pending
);
assert_eq!(
r.push(7, parse(&frames[2]).unwrap()).unwrap(),
Reassembly::Pending
);
assert_eq!(r.missing(7, 3), Some(39));
assert_eq!(
r.push(7, parse(&frames[1]).unwrap()).unwrap(),
Reassembly::Done(datagram)
);
}
#[test]
fn crc_and_bounds() {
let mut f = segment(&[1, 2, 3], 1, 39).remove(0);
f[5] ^= 1;
assert_eq!(parse(&f), Err(Error::Crc));
let mut r = Reassembler::default();
let bogus = Segment::Subsequent {
size: 4,
session: 1,
offset: 3,
data: vec![1, 2],
};
assert!(r.push(1, bogus).is_err());
r.push(
1,
Segment::First {
size: 4,
session: 1,
data: vec![1],
},
)
.unwrap();
assert_eq!(
r.push(
1,
Segment::Subsequent {
size: 4,
session: 1,
offset: 3,
data: vec![1, 2]
}
),
Err(Error::OutOfBounds)
);
assert_eq!(
parse(&request(2, 300)).unwrap(),
Segment::Request {
session: 2,
offset: 300
}
);
assert_eq!(
parse(&complete(5)).unwrap(),
Segment::Complete { session: 5 }
);
}
}