use crate::time::{Duration, Instant};
use std::collections::VecDeque;
use crate::client::{Error, OutgoingFile};
use crate::codec::{BlockCheck, CR, Deframer, FrameError, Framing, Packet, parse_frame, unchar};
use crate::params::{InitParams, Negotiated, negotiate};
use crate::prefix::{self, Quoting};
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ServerConfig {
pub block_check: BlockCheck,
pub eight_bit_clean: bool,
pub timeout: Duration,
pub retries: u32,
pub packet_pause: Duration,
pub max_size: Option<usize>,
}
impl Default for ServerConfig {
fn default() -> Self {
ServerConfig {
block_check: BlockCheck::Type3,
eight_bit_clean: true,
timeout: Duration::from_secs(10),
retries: 5,
packet_pause: Duration::ZERO,
max_size: Some(4 << 20),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum ServerEvent {
Request {
name: Vec<u8>,
},
FileStart {
name: Vec<u8>,
sending: bool,
},
Progress {
done: u64,
total: Option<u64>,
},
Received {
name: Vec<u8>,
data: Vec<u8>,
},
Discarded {
name: Vec<u8>,
},
Sent {
name: Vec<u8>,
},
Remote(Vec<u8>),
Error(Error),
Done,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct NoRequest;
impl std::fmt::Display for NoRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("no file request is waiting for an answer")
}
}
impl std::error::Error for NoRequest {}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Step {
Init,
File,
Data { chunk: usize },
Eof,
Break,
}
#[derive(Debug)]
struct Sending {
file: OutgoingFile,
pos: usize,
step: Step,
}
#[derive(Debug)]
enum Phase {
Idle,
Requested,
Send(Sending),
Receive {
name: Option<Vec<u8>>,
data: Vec<u8>,
},
}
#[derive(Debug)]
pub struct Server {
config: ServerConfig,
ours: InitParams,
deframer: Deframer,
phase: Phase,
neg: Option<Negotiated>,
seq: u8,
last_sent: Vec<u8>,
answered: Option<(u8, u8)>,
queue: VecDeque<(Instant, Vec<u8>)>,
events: VecDeque<ServerEvent>,
deadline: Option<Instant>,
retries: u32,
received: usize,
}
impl Server {
pub fn new(config: ServerConfig) -> Self {
let ours = InitParams {
maxl: 94,
time: config.timeout.as_secs().clamp(1, 94) as u8,
npad: 0,
padc: 0,
eol: CR,
qctl: b'#',
qbin: if config.eight_bit_clean { b'Y' } else { b'&' },
chkt: config.block_check.to_char(),
rept: b' ',
};
Server {
config,
ours,
deframer: Deframer::new(),
phase: Phase::Idle,
neg: None,
seq: 0,
last_sent: Vec::new(),
answered: None,
queue: VecDeque::new(),
events: VecDeque::new(),
deadline: None,
retries: 0,
received: 0,
}
}
pub fn params(&self) -> InitParams {
self.ours
}
pub fn handle_input(&mut self, now: Instant, bytes: &[u8]) {
self.deframer.push(bytes);
while let Some(frame) = self.deframer.next_frame() {
let kind = frame.get(3).copied();
let check = match (&self.phase, self.neg) {
(Phase::Receive { .. }, Some(n)) if kind != Some(b'S') => n.check,
(Phase::Send(s), Some(n)) if s.step != Step::Init => n.check,
_ => BlockCheck::Type1,
};
let mut parsed = parse_frame(&frame, check);
if let (Phase::Idle, Err(FrameError::BadCheck), Some(n)) =
(&self.phase, &parsed, self.neg)
{
parsed = parse_frame(&frame, n.check);
}
if frame.get(2).is_some_and(|c| !(32..=95).contains(c)) {
parsed = Err(FrameError::BadLength);
}
let raw_seq = frame.get(2).map(|&c| unchar(c));
match self.phase {
Phase::Idle => self.on_idle(now, parsed),
Phase::Requested => self.on_requested(now, parsed),
Phase::Send(_) => self.on_send(now, parsed, raw_seq),
Phase::Receive { .. } => self.on_receive(now, parsed),
}
}
}
pub fn handle_timeout(&mut self, now: Instant) {
let Some(d) = self.deadline else { return };
if now < d {
return;
}
self.deadline = None;
match self.phase {
Phase::Receive { .. } => {
let nak = self.nak();
self.retry_with(now, nak);
}
Phase::Send(_) => {
let bytes = self.last_sent.clone();
self.retry_with(now, bytes);
}
Phase::Idle | Phase::Requested => {}
}
}
pub fn poll_output(&mut self, now: Instant) -> Option<Vec<u8>> {
match self.queue.front() {
Some((due, _)) if *due <= now => {}
_ => return None,
}
let (_, bytes) = self.queue.pop_front()?;
if matches!(self.phase, Phase::Send(_) | Phase::Receive { .. }) {
self.deadline = now.checked_add(self.config.timeout);
}
Some(bytes)
}
pub fn poll_event(&mut self) -> Option<ServerEvent> {
self.events.pop_front()
}
pub fn next_timeout(&self) -> Option<Instant> {
let due = self.queue.iter().map(|(t, _)| *t).min();
match (due, self.deadline) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
}
}
pub fn is_idle(&self) -> bool {
matches!(self.phase, Phase::Idle)
}
pub fn is_requested(&self) -> bool {
matches!(self.phase, Phase::Requested)
}
pub fn serve(&mut self, now: Instant, file: OutgoingFile) -> Result<(), NoRequest> {
if !self.is_requested() {
return Err(NoRequest);
}
self.neg = None;
self.seq = 0;
self.retries = 0;
self.answered = None;
self.phase = Phase::Send(Sending {
file,
pos: 0,
step: Step::Init,
});
let bytes =
Packet::new(0, b'S', self.ours.encode()).wire(BlockCheck::Type1, &Framing::default());
self.reply(now, bytes);
Ok(())
}
pub fn refuse(&mut self, now: Instant, text: &[u8]) -> Result<(), NoRequest> {
if !self.is_requested() {
return Err(NoRequest);
}
let data = prefix::encode_all(text, &Quoting::default());
let bytes = Packet::new(self.seq, b'E', data).wire(BlockCheck::Type1, &Framing::default());
self.queue.push_back((self.paused(now), bytes));
self.go_idle();
Ok(())
}
pub fn cancel(&mut self, now: Instant) {
if !self.is_idle() {
self.fail(now, Error::Cancelled, Some(b"Cancelled"));
}
}
fn check(&self) -> BlockCheck {
self.neg.map_or(BlockCheck::Type1, |n| n.check)
}
fn framing(&self) -> Framing {
self.neg.map_or_else(Framing::default, |n| n.framing)
}
fn send_quoting(&self) -> Quoting {
self.neg.map_or_else(Quoting::default, |n| n.send)
}
fn recv_quoting(&self) -> Quoting {
self.neg.map_or_else(Quoting::default, |n| n.recv)
}
fn paused(&self, now: Instant) -> Instant {
now.checked_add(self.config.packet_pause).unwrap_or(now)
}
fn nak(&self) -> Vec<u8> {
Packet::new(self.seq, b'N', Vec::new()).wire(self.check(), &self.framing())
}
fn reply(&mut self, now: Instant, bytes: Vec<u8>) {
self.last_sent = bytes.clone();
self.deadline = None;
let due = self.paused(now);
self.queue.push_back((due, bytes));
}
fn reply_packet(&mut self, now: Instant, seq: u8, kind: u8, data: Vec<u8>) {
let bytes = Packet::new(seq, kind, data).wire(self.check(), &self.framing());
self.reply(now, bytes);
}
fn retry_with(&mut self, now: Instant, bytes: Vec<u8>) {
self.retries += 1;
if self.retries > self.config.retries {
self.fail(now, Error::Timeout, Some(b"Too many retries"));
} else {
self.deadline = None;
let due = self.paused(now);
self.queue.push_back((due, bytes));
}
}
fn go_idle(&mut self) {
self.phase = Phase::Idle;
self.deadline = None;
self.retries = 0;
}
fn finish(&mut self, event: ServerEvent, answered: Option<(u8, u8)>) {
self.events.push_back(event);
self.go_idle();
self.answered = answered;
}
fn fail(&mut self, now: Instant, err: Error, text: Option<&[u8]>) {
self.queue.clear();
if let Some(text) = text {
let data = prefix::encode_all(text, &self.send_quoting());
let bytes = Packet::new(self.seq, b'E', data).wire(self.check(), &self.framing());
self.queue.push_back((now, bytes));
}
self.finish(ServerEvent::Error(err), None);
}
fn protocol(&mut self, now: Instant, msg: String, text: &[u8]) {
self.fail(now, Error::Protocol(msg), Some(text));
}
fn remote(&mut self, data: &[u8], q: &Quoting) {
let text = prefix::decode(data, q).unwrap_or_else(|_| data.to_vec());
self.finish(ServerEvent::Remote(text), None);
}
fn decode(&mut self, now: Instant, data: &[u8], q: &Quoting) -> Option<Vec<u8>> {
match prefix::decode(data, q) {
Ok(v) => Some(v),
Err(e) => {
self.protocol(now, e.to_string(), b"Bad prefix");
None
}
}
}
fn on_idle(&mut self, now: Instant, parsed: Result<Packet, FrameError>) {
let Ok(p) = parsed else { return };
if self.answered == Some((p.seq, p.kind)) && p.kind != b'E' && p.kind != b'N' {
let due = self.paused(now);
self.queue.push_back((due, self.last_sent.clone()));
return;
}
match p.kind {
b'I' => {
self.neg = None;
let bytes = Packet::new(p.seq, b'Y', self.ours.encode())
.wire(BlockCheck::Type1, &Framing::default());
self.reply(now, bytes);
self.answered = Some((p.seq, b'I'));
}
b'S' => {
let theirs = InitParams::decode(&p.data);
let n = negotiate(&self.ours, &theirs);
let bytes = Packet::new(p.seq, b'Y', self.ours.encode())
.wire(BlockCheck::Type1, &n.framing);
self.reply(now, bytes);
self.neg = Some(n);
self.seq = (p.seq + 1) % 64;
self.retries = 0;
self.received = 0;
self.answered = None;
self.phase = Phase::Receive {
name: None,
data: Vec::new(),
};
}
b'R' => {
let Some(name) = self.decode(now, &p.data, &Quoting::default()) else {
return;
};
self.neg = None;
self.seq = p.seq;
self.answered = None;
self.phase = Phase::Requested;
self.events.push_back(ServerEvent::Request { name });
}
b'E' => {
let text = prefix::decode(&p.data, &Quoting::default()).unwrap_or(p.data);
self.events.push_back(ServerEvent::Remote(text));
}
b'N' | b'Y' => {}
_ => {
let data = prefix::encode_all(b"Unimplemented", &Quoting::default());
let bytes =
Packet::new(p.seq, b'E', data).wire(BlockCheck::Type1, &Framing::default());
self.reply(now, bytes);
self.answered = Some((p.seq, p.kind));
}
}
}
fn on_requested(&mut self, now: Instant, parsed: Result<Packet, FrameError>) {
let Ok(p) = parsed else { return };
match p.kind {
b'E' => {
let text = prefix::decode(&p.data, &Quoting::default()).unwrap_or(p.data);
self.finish(ServerEvent::Remote(text), None);
}
b'I' | b'S' => {
self.go_idle();
self.on_idle(now, Ok(p));
}
_ => {}
}
}
fn on_receive(&mut self, now: Instant, parsed: Result<Packet, FrameError>) {
let n = self.seq;
let p = match parsed {
Ok(p) => p,
Err(FrameError::BadCheck) => {
let nak = self.nak();
self.retry_with(now, nak);
return;
}
Err(FrameError::BadLength) => return,
};
if p.kind == b'E' {
let q = self.recv_quoting();
self.remote(&p.data, &q);
return;
}
if p.seq != n {
if p.seq == (n + 63) % 64 && p.kind != b'N' {
self.retries = 0;
let due = self.paused(now);
self.queue.push_back((due, self.last_sent.clone()));
self.deadline = None;
}
return;
}
let q = self.recv_quoting();
match p.kind {
b'F' => {
let Some(name) = self.decode(now, &p.data, &q) else {
return;
};
self.events.push_back(ServerEvent::FileStart {
name: name.clone(),
sending: false,
});
if let Phase::Receive { name: n, data } = &mut self.phase {
*n = Some(name);
data.clear();
}
self.reply_packet(now, n, b'Y', p.data);
}
b'D' => {
let Some(chunk) = self.decode(now, &p.data, &q) else {
return;
};
self.received = self.received.saturating_add(chunk.len());
if let Some(limit) = self.config.max_size
&& self.received > limit
{
self.fail(now, Error::TooLarge { limit }, Some(b"Too large"));
return;
}
let Phase::Receive {
name: Some(_),
data,
} = &mut self.phase
else {
self.protocol(now, "D before F".to_string(), b"Unexpected packet");
return;
};
data.extend_from_slice(&chunk);
let done = data.len() as u64;
self.events
.push_back(ServerEvent::Progress { done, total: None });
self.reply_packet(now, n, b'Y', Vec::new());
}
b'Z' => {
let Some(flag) = self.decode(now, &p.data, &q) else {
return;
};
let Phase::Receive { name, data } = &mut self.phase else {
return;
};
let Some(name) = name.take() else {
self.protocol(now, "Z before F".to_string(), b"Unexpected packet");
return;
};
let data = std::mem::take(data);
self.events.push_back(if flag == b"D" {
ServerEvent::Discarded { name }
} else {
ServerEvent::Received { name, data }
});
self.reply_packet(now, n, b'Y', Vec::new());
}
b'A' | b'X' => self.reply_packet(now, n, b'Y', Vec::new()),
b'B' => {
if matches!(&self.phase, Phase::Receive { name: Some(_), .. }) {
self.protocol(
now,
"B before the Z of the current file".to_string(),
b"Unexpected B",
);
return;
}
self.reply_packet(now, n, b'Y', Vec::new());
self.finish(ServerEvent::Done, Some((n, b'B')));
return;
}
b'N' => return,
other => {
self.protocol(
now,
format!("unexpected packet {:?}", char::from(other)),
b"Unexpected packet",
);
return;
}
}
self.seq = (n + 1) % 64;
self.retries = 0;
}
fn on_send(&mut self, now: Instant, parsed: Result<Packet, FrameError>, raw_seq: Option<u8>) {
let n = self.seq;
let p = match parsed {
Ok(p) => p,
Err(FrameError::BadCheck) => {
if raw_seq == Some(n) {
let bytes = self.last_sent.clone();
self.retry_with(now, bytes);
}
return;
}
Err(FrameError::BadLength) => return,
};
match p.kind {
b'E' => {
let q = self.recv_quoting();
self.remote(&p.data, &q);
}
b'Y' if p.seq == n => {
let sent = std::mem::take(&mut self.last_sent);
self.queue.retain(|(_, b)| *b != sent);
self.last_sent = sent;
self.on_ack(now, &p.data);
}
b'N' if p.seq == (n + 1) % 64 => self.on_ack(now, &[]),
b'N' if p.seq == n => {
let bytes = self.last_sent.clone();
self.retry_with(now, bytes);
}
_ => {}
}
}
fn sending(&mut self) -> Option<&mut Sending> {
match &mut self.phase {
Phase::Send(s) => Some(s),
_ => None,
}
}
fn send_next(&mut self, now: Instant, kind: u8, data: Vec<u8>) {
self.seq = (self.seq + 1) % 64;
self.reply_packet(now, self.seq, kind, data);
}
fn max_data(&self) -> usize {
let maxl = self.neg.map_or(80, |n| usize::from(n.peer_maxl));
Packet::max_data(maxl, self.check())
}
fn on_ack(&mut self, now: Instant, data: &[u8]) {
self.retries = 0;
let Some(step) = self.sending().map(|s| s.step) else {
return;
};
match step {
Step::Init => {
let theirs = InitParams::decode(data);
self.neg = Some(negotiate(&self.ours, &theirs));
let max = self.max_data();
let q = self.send_quoting();
let Some(s) = self.sending() else { return };
let (name, used) = prefix::encode(&s.file.name, &q, max);
if used != s.file.name.len() {
self.protocol(
now,
format!("file name does not fit in a packet of {max} data bytes"),
b"File name too long",
);
return;
}
s.step = Step::File;
self.send_next(now, b'F', name);
}
Step::File => {
let name = if data.is_empty() {
self.sending()
.map(|s| s.file.name.clone())
.unwrap_or_default()
} else {
let q = self.recv_quoting();
let Some(name) = self.decode(now, data, &q) else {
return;
};
name
};
self.events.push_back(ServerEvent::FileStart {
name,
sending: true,
});
self.next_data(now);
}
Step::Data { chunk } => {
let Some(s) = self.sending() else { return };
s.pos += chunk;
let done = s.pos as u64;
let total = s.file.data.len() as u64;
self.events.push_back(ServerEvent::Progress {
done,
total: Some(total),
});
self.next_data(now);
}
Step::Eof => {
let Some(s) = self.sending() else { return };
s.step = Step::Break;
let name = s.file.name.clone();
self.events.push_back(ServerEvent::Sent { name });
self.send_next(now, b'B', Vec::new());
}
Step::Break => self.finish(ServerEvent::Done, None),
}
}
fn next_data(&mut self, now: Instant) {
let max = self.max_data();
let q = self.send_quoting();
let Some(s) = self.sending() else { return };
let rest = s.file.data.get(s.pos..).unwrap_or_default();
if rest.is_empty() {
s.step = Step::Eof;
self.send_next(now, b'Z', Vec::new());
} else {
let (enc, used) = prefix::encode(rest, &q, max);
s.step = Step::Data { chunk: used };
self.send_next(now, b'D', enc);
}
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
pub(crate) mod test_support {
use super::*;
use crate::trace::{self, Direction};
pub(crate) fn replay_server(
config: ServerConfig,
text: &str,
answer: &dyn Fn(&[u8]) -> Option<Vec<u8>>,
) -> (Server, Vec<ServerEvent>) {
let now = Instant::now();
let mut s = Server::new(config);
let mut events = Vec::new();
for (i, (dir, bytes)) in trace::parse(text).unwrap().into_iter().enumerate() {
match dir {
Direction::Out => {
let got = s.poll_output(now);
assert_eq!(
got.as_deref().map(trace::escape),
Some(trace::escape(&bytes)),
"trace entry {i}: expected output > {}",
trace::escape(&bytes)
);
}
Direction::In => s.handle_input(now, &bytes),
}
while let Some(e) = s.poll_event() {
if let ServerEvent::Request { name } = &e {
match answer(name) {
Some(data) => s
.serve(
now,
OutgoingFile {
name: name.clone(),
data,
},
)
.unwrap(),
None => s.refuse(now, b"File not found").unwrap(),
}
}
events.push(e);
}
}
let extra = s.poll_output(now);
assert_eq!(
extra.as_deref().map(trace::escape),
None,
"unexpected trailing output"
);
(s, events)
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::test_support::replay_server;
use super::*;
use crate::trace;
const T1: BlockCheck = BlockCheck::Type1;
const T3: BlockCheck = BlockCheck::Type3;
const CALC: &[u8] = b"~* @-#Y3";
const CALC_ACK: &[u8] = b"~& @-# 1";
const OURS: &[u8] = b"~* @-#Y3 ";
fn wire(seq: u8, kind: u8, data: &[u8], check: BlockCheck) -> Vec<u8> {
Packet::new(seq, kind, data.to_vec())
.encode(check, &Framing::default())
.unwrap()
}
fn out(seq: u8, kind: u8, data: &[u8], check: BlockCheck) -> String {
format!("> {}\n", trace::escape(&wire(seq, kind, data, check)))
}
fn inp(seq: u8, kind: u8, data: &[u8], check: BlockCheck) -> String {
format!("< {}\n", trace::escape(&wire(seq, kind, data, check)))
}
fn none(_: &[u8]) -> Option<Vec<u8>> {
None
}
#[test]
fn our_params_encode() {
assert_eq!(Server::new(ServerConfig::default()).params().encode(), OURS);
}
#[test]
fn info_then_refused_request() {
let mut t = inp(0, b'I', CALC, T1) + &out(0, b'Y', OURS, T1);
t += &inp(0, b'I', CALC, T1);
t += &out(0, b'Y', OURS, T1);
t += &inp(0, b'R', b"HP38DIR.CUR", T1);
t += &out(0, b'E', b"File not found", T1);
t += &inp(0, b'E', b"Transfer Failed#M#J", T1);
let (s, ev) = replay_server(ServerConfig::default(), &t, &none);
assert_eq!(
ev,
vec![
ServerEvent::Request {
name: b"HP38DIR.CUR".to_vec()
},
ServerEvent::Remote(b"Transfer Failed\r\n".to_vec()),
]
);
assert!(s.is_idle());
assert_eq!(s.next_timeout(), None);
}
#[test]
fn serves_a_file() {
let mut t = inp(0, b'R', b"FUNCTION.000", T1);
t += &out(0, b'S', OURS, T1);
t += &inp(0, b'Y', CALC_ACK, T1);
t += &out(1, b'F', b"FUNCTION.000", T1);
t += &inp(1, b'Y', b"FUNCTION.000", T1);
t += &out(2, b'D', b"HP38BinB#H", T1);
t += &inp(2, b'Y', b"", T1);
t += &out(3, b'Z', b"", T1);
t += &inp(3, b'Y', b"", T1);
t += &out(4, b'B', b"", T1);
t += &inp(4, b'Y', b"", T1);
let answer = |_: &[u8]| Some(b"HP38BinB\x08".to_vec());
let (s, ev) = replay_server(ServerConfig::default(), &t, &answer);
let name = b"FUNCTION.000".to_vec();
assert_eq!(
ev,
vec![
ServerEvent::Request { name: name.clone() },
ServerEvent::FileStart {
name: name.clone(),
sending: true
},
ServerEvent::Progress {
done: 9,
total: Some(9)
},
ServerEvent::Sent { name },
ServerEvent::Done,
]
);
assert!(s.is_idle());
}
#[test]
fn receives_a_file_with_crc_and_a_doubled_s() {
let mut t = inp(0, b'S', CALC, T1) + &out(0, b'Y', OURS, T1);
t += &inp(0, b'S', CALC, T1);
t += &out(0, b'Y', OURS, T1);
t += &inp(1, b'F', b"XYZ00000.000", T3);
t += &out(1, b'Y', b"XYZ00000.000", T3);
t += &inp(2, b'D', b"HP39BinB#CXYZ", T3);
t += &out(2, b'Y', b"", T3);
t += &inp(3, b'Z', b"", T3);
t += &out(3, b'Y', b"", T3);
t += &inp(4, b'B', b"", T3);
t += &out(4, b'Y', b"", T3);
t += &inp(4, b'B', b"", T3);
t += &out(4, b'Y', b"", T3);
let (s, ev) = replay_server(ServerConfig::default(), &t, &none);
let name = b"XYZ00000.000".to_vec();
assert_eq!(
ev,
vec![
ServerEvent::FileStart {
name: name.clone(),
sending: false
},
ServerEvent::Progress {
done: 12,
total: None
},
ServerEvent::Received {
name,
data: b"HP39BinB\x03XYZ".to_vec()
},
ServerEvent::Done,
]
);
assert!(s.is_idle());
}
#[test]
fn type1_when_asked() {
let cfg = ServerConfig {
block_check: T1,
..ServerConfig::default()
};
let ours = b"~* @-#Y1 ";
let mut t = inp(0, b'S', CALC, T1) + &out(0, b'Y', ours, T1);
t += &inp(1, b'F', b"A.000", T1);
t += &out(1, b'Y', b"A.000", T1);
t += &inp(2, b'Z', b"D", T1);
t += &out(2, b'Y', b"", T1);
t += &inp(3, b'B', b"", T1);
t += &out(3, b'Y', b"", T1);
let (_, ev) = replay_server(cfg, &t, &none);
assert_eq!(
ev,
vec![
ServerEvent::FileStart {
name: b"A.000".to_vec(),
sending: false
},
ServerEvent::Discarded {
name: b"A.000".to_vec()
},
ServerEvent::Done,
]
);
}
#[test]
fn generic_commands_are_refused() {
let t = inp(0, b'G', b"D", T1) + &out(0, b'E', b"Unimplemented", T1);
let (s, ev) = replay_server(ServerConfig::default(), &t, &none);
assert!(ev.is_empty());
assert!(s.is_idle());
}
#[test]
fn calculator_error_ends_a_receive() {
let mut t = inp(0, b'S', CALC, T1) + &out(0, b'Y', OURS, T1);
t += &inp(1, b'E', b"Cancelled", T3);
let (s, ev) = replay_server(ServerConfig::default(), &t, &none);
assert_eq!(ev, vec![ServerEvent::Remote(b"Cancelled".to_vec())]);
assert!(s.is_idle());
}
#[test]
fn receive_timeouts_nak_then_fail() {
let now = Instant::now();
let cfg = ServerConfig {
retries: 1,
..ServerConfig::default()
};
let mut s = Server::new(cfg);
s.handle_input(now, &wire(0, b'S', CALC, T1));
assert_eq!(s.poll_output(now), Some(wire(0, b'Y', OURS, T1)));
let t1 = s.next_timeout().unwrap();
assert_eq!(t1, now + Duration::from_secs(10));
s.handle_timeout(t1);
assert_eq!(s.poll_output(t1), Some(wire(1, b'N', b"", T3)));
let t2 = s.next_timeout().unwrap();
s.handle_timeout(t2);
assert_eq!(
s.poll_output(t2),
Some(wire(1, b'E', b"Too many retries", T3))
);
assert_eq!(s.poll_event(), Some(ServerEvent::Error(Error::Timeout)));
assert!(s.is_idle());
assert_eq!(s.next_timeout(), None);
}
#[test]
fn send_resends_on_nak_and_timeout() {
let now = Instant::now();
let mut s = Server::new(ServerConfig::default());
s.handle_input(now, &wire(0, b'R', b"A", T1));
assert!(s.is_requested());
assert_eq!(
s.poll_event(),
Some(ServerEvent::Request {
name: b"A".to_vec()
})
);
s.serve(
now,
OutgoingFile {
name: b"A".to_vec(),
data: b"x".to_vec(),
},
)
.unwrap();
let first = s.poll_output(now).unwrap();
s.handle_input(now, &wire(0, b'N', b"", T1));
assert_eq!(s.poll_output(now), Some(first.clone()));
let t = s.next_timeout().unwrap();
s.handle_timeout(t);
assert_eq!(s.poll_output(t), Some(first));
assert_eq!(
s.serve(
now,
OutgoingFile {
name: vec![],
data: vec![]
}
),
Err(NoRequest)
);
}
#[test]
fn cancel_while_requested() {
let now = Instant::now();
let mut s = Server::new(ServerConfig::default());
s.handle_input(now, &wire(0, b'R', b"A", T1));
s.cancel(now);
assert_eq!(s.poll_output(now), Some(wire(0, b'E', b"Cancelled", T1)));
assert_eq!(
s.poll_event(),
Some(ServerEvent::Request {
name: b"A".to_vec()
})
);
assert_eq!(s.poll_event(), Some(ServerEvent::Error(Error::Cancelled)));
assert!(s.is_idle());
}
#[test]
fn a_seq_out_of_range_is_ignored() {
let now = Instant::now();
let mut s = Server::new(ServerConfig::default());
for seq_byte in [0x1f_u8, 0x7e] {
for kind in *b"SIR" {
let mut frame = vec![crate::codec::SOH, crate::codec::tochar(3), seq_byte, kind];
let chk = T1.compute(&frame[1..]);
frame.extend_from_slice(&chk);
frame.push(CR);
s.handle_input(now, &frame);
}
}
assert_eq!(s.poll_output(now), None);
assert_eq!(s.poll_event(), None);
assert!(s.is_idle());
}
}