use xmodem_proto::{BlockSize, Check, Command, Config, Event, Transfer};
use crate::calc::Model;
#[cfg(not(target_arch = "wasm32"))]
use crate::link;
use crate::link::{Link, Progress};
use crate::object::{HEADER_LEN, inspect, strip_padding};
use crate::time::Duration;
#[cfg(not(target_arch = "wasm32"))]
use crate::time::Instant;
#[cfg(not(target_arch = "wasm32"))]
use crate::transport::Transport;
use crate::watchdog::Watchdog;
use crate::{Error, Result};
const IDLE_WAIT: Duration = Duration::from_millis(100);
const MIN_WAIT: Duration = Duration::from_millis(10);
pub const MAX_START_TIMEOUT: Duration = Duration::from_secs(600);
pub const MIN_START_TIMEOUT: Duration = Duration::from_secs(1);
#[derive(Clone, Debug)]
pub struct XmodemOptions {
pub xmodem: Config,
pub start_timeout: Duration,
pub drain: Duration,
}
impl Default for XmodemOptions {
fn default() -> Self {
let mut xmodem = Config::default();
xmodem.block_size = BlockSize::B1k;
xmodem.linger = Duration::from_millis(200);
XmodemOptions {
xmodem,
start_timeout: Duration::from_secs(60),
drain: Duration::ZERO,
}
}
}
impl XmodemOptions {
pub fn for_model(model: Model) -> Result<Self> {
let base = XmodemOptions::default();
match model {
Model::Hp48Sx => Err(Error::Unsupported(
"the HP 48S/SX has no XModem; use Kermit".into(),
)),
Model::Hp38G => Err(Error::Unsupported(
"the HP 38G has no XModem; it sends and receives aplets as a Kermit client".into(),
)),
Model::Hp49G => {
let mut xmodem = base.xmodem.clone();
xmodem.check = Check::HpCrc;
xmodem.crc_attempts = u32::MAX;
xmodem.block_size = BlockSize::B1k;
Ok(XmodemOptions { xmodem, ..base })
}
Model::Hp39G => {
let mut xmodem = base.xmodem.clone();
xmodem.check = Check::Checksum;
xmodem.block_size = BlockSize::B128;
xmodem.pad = 0;
Ok(XmodemOptions { xmodem, ..base })
}
Model::Hp48Gx => {
let mut xmodem = base.xmodem.clone();
xmodem.check = Check::Checksum;
xmodem.block_size = BlockSize::B128;
xmodem.timeout = Duration::from_secs(3);
Ok(XmodemOptions { xmodem, ..base })
}
Model::Unknown => Ok(base),
}
}
fn config(&self) -> Config {
let start = self
.start_timeout
.clamp(MIN_START_TIMEOUT, MAX_START_TIMEOUT);
let mut config = self.xmodem.clone();
config.start_timeout = start;
config.recv_start_timeout = Some(start);
config
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct XmodemReport {
pub check: Check,
pub bytes: u64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct XmodemReceived {
pub data: Vec<u8>,
pub check: Check,
pub received: usize,
pub last_block: usize,
pub stripped: Option<usize>,
}
#[cfg(not(target_arch = "wasm32"))]
pub struct XmodemSession {
transport: Box<dyn Transport>,
options: XmodemOptions,
link: Link,
}
#[cfg(not(target_arch = "wasm32"))]
impl std::fmt::Debug for XmodemSession {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XmodemSession")
.field("options", &self.options)
.finish_non_exhaustive()
}
}
struct Outcome {
check: Option<Check>,
bytes: u64,
file: Option<(Vec<u8>, usize)>,
}
#[cfg(not(target_arch = "wasm32"))]
impl XmodemSession {
pub fn new(transport: Box<dyn Transport>, options: XmodemOptions) -> Self {
XmodemSession {
transport,
options,
link: Link::new(Instant::now()),
}
}
pub fn options(&self) -> &XmodemOptions {
&self.options
}
pub fn into_transport(self) -> Box<dyn Transport> {
self.transport
}
pub fn send(&mut self, data: &[u8]) -> Result<XmodemReport> {
self.send_with(data, &mut |_| {})
}
pub fn send_with(
&mut self,
data: &[u8],
progress: &mut dyn FnMut(&Event),
) -> Result<XmodemReport> {
link::drive(
self.transport.as_mut(),
&self.link,
send(&self.link, &self.options, data),
&mut |p| {
if let Progress::Xmodem(event) = p {
progress(event);
}
},
)
}
pub fn receive(&mut self) -> Result<XmodemReceived> {
self.receive_with(&mut |_| {})
}
pub fn receive_with(&mut self, progress: &mut dyn FnMut(&Event)) -> Result<XmodemReceived> {
link::drive(
self.transport.as_mut(),
&self.link,
receive(&self.link, &self.options),
&mut |p| {
if let Progress::Xmodem(event) = p {
progress(event);
}
},
)
}
}
pub(crate) async fn send(
link: &Link,
options: &XmodemOptions,
data: &[u8],
) -> Result<XmodemReport> {
let outcome = run(link, options, Command::Send(data.to_vec())).await?;
Ok(XmodemReport {
check: outcome.check.unwrap_or(options.xmodem.check),
bytes: outcome.bytes,
})
}
pub(crate) async fn receive(link: &Link, options: &XmodemOptions) -> Result<XmodemReceived> {
let outcome = run(link, options, Command::Receive).await?;
let (raw, last_block) = outcome
.file
.ok_or_else(|| Error::Reply("XModem transfer ended without a file".into()))?;
let object_len = inspect(&raw)
.ok()
.and_then(|i| i.size_nibbles)
.map(|n| HEADER_LEN + n.div_ceil(2));
let data = strip_padding(&raw, last_block.saturating_sub(1)).to_vec();
let stripped = match object_len {
Some(len) if data.len() == len => Some(raw.len() - len),
_ => None,
};
Ok(XmodemReceived {
check: outcome.check.unwrap_or(options.xmodem.check),
received: raw.len(),
last_block,
stripped,
data,
})
}
async fn run(link: &Link, options: &XmodemOptions, command: Command) -> Result<Outcome> {
link.drain(options.drain).await?;
let config = options.config();
let start_limit = config.start_timeout.saturating_add(config.timeout);
let stall_limit = config
.timeout
.saturating_mul(config.retries.saturating_add(2))
.saturating_add(config.purge)
.saturating_add(config.byte_timeout);
let mut xfer = Transfer::new(config);
let begin = link.now();
xfer.start(begin, command)
.map_err(|e| Error::Reply(format!("XModem: {e}")))?;
let mut watchdog = Watchdog::new(begin, start_limit, stall_limit);
let mut stalled = false;
let mut out = Outcome {
check: None,
bytes: 0,
file: None,
};
let mut result: Option<Result<()>> = None;
'run: loop {
let now = link.now();
while let Some(bytes) = xfer.poll_output(now) {
match link.write(bytes) {
Ok(()) => {}
Err(_) if matches!(result, Some(Ok(()))) => break 'run,
Err(e) => return Err(e.into()),
}
}
match link.flush().await {
Ok(()) => {}
Err(_) if matches!(result, Some(Ok(()))) => break 'run,
Err(e) => return Err(e.into()),
}
while let Some(event) = xfer.poll_event() {
link.emit(Progress::Xmodem(event.clone()));
match event {
Event::Started { check } => {
out.check = Some(check);
watchdog.progress(now);
}
Event::Progress { bytes, .. } => {
out.bytes = bytes;
watchdog.progress(now);
}
Event::FileEnd {
data, last_block, ..
} => out.file = Some((data, last_block)),
Event::Done => result = Some(Ok(())),
Event::Error(xmodem_proto::Error::Cancelled) if stalled => {
result = Some(Err(Error::Xmodem(xmodem_proto::Error::Timeout)));
}
Event::Error(e) => result = Some(Err(Error::Xmodem(e))),
_ => {}
}
}
if result.is_some() && xfer.next_timeout().is_none() {
if xfer.poll_output(now).is_none() {
break;
}
continue;
}
if result.is_none() && watchdog.expired(now) {
stalled = true;
xfer.cancel(now);
continue;
}
let until = match (xfer.next_timeout(), watchdog.deadline()) {
(Some(a), Some(b)) => Some(a.min(b)),
(a, b) => a.or(b),
};
let deadline = until.unwrap_or(now + IDLE_WAIT).max(now + MIN_WAIT);
let input = match link.read(Some(deadline)).await {
Ok(input) => input,
Err(_) if matches!(result, Some(Ok(()))) => break,
Err(e) => return Err(e.into()),
};
let now = link.now();
if !input.is_empty() {
xfer.handle_input(now, &input);
}
xfer.handle_timeout(now);
}
match result {
Some(Err(e)) => Err(e),
_ => Ok(out),
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum XmodemDirection {
ToCalculator,
FromCalculator,
}
impl XmodemDirection {
pub fn calculator_command(self) -> &'static str {
match self {
XmodemDirection::ToCalculator => "XRECV",
XmodemDirection::FromCalculator => "XSEND",
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct XmodemPlan {
pub model: Model,
pub direction: XmodemDirection,
pub name: String,
pub keys: String,
pub switched_to_rpn: bool,
pub exists: bool,
pub notes: Vec<String>,
}
impl XmodemPlan {
pub fn instructions(&self) -> String {
let mut text = format!("On the calculator, type {} and press ENTER.", self.keys);
for note in &self.notes {
text.push(' ');
text.push_str(note);
}
text
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
use crate::object;
use crate::transport::MemoryTransport;
use std::collections::VecDeque;
use std::io;
use std::sync::{Arc, Mutex};
use xmodem_proto::codec::{ACK, CAN, EOT, NAK, SOH, STX, decode_block, encode_block};
const G49_XSEND_HPCRC: &str = include_str!("../../xmodem-proto/traces/49g-xsend-hpcrc.trace");
const G49_XSEND: &str = include_str!("../../xmodem-proto/traces/49g-xsend.trace");
const GX_XSEND: &str = include_str!("../../xmodem-proto/traces/48gx-xsend.trace");
const G49_XRECV: &str = include_str!("../../xmodem-proto/traces/49g-xrecv.trace");
const GX_XRECV: &str = include_str!("../../xmodem-proto/traces/48gx-xrecv.trace");
const H49: &[u8; 8] = b"HPHP49-C";
const H48: &[u8; 8] = b"HPHP48-R";
fn hp_string(header: &[u8; 8], chars: &[u8]) -> Vec<u8> {
let len = 5 + 2 * chars.len();
let mut nibbles = vec![0xC, 0x2, 0xA, 0x2, 0x0];
nibbles.extend((0..5).map(|i| ((len >> (4 * i)) & 0xF) as u8));
let mut out = header.to_vec();
out.extend(object::pack(&nibbles));
out.extend_from_slice(chars);
out
}
fn all_bytes(header: &[u8; 8]) -> Vec<u8> {
hp_string(header, &(0..=255).collect::<Vec<u8>>())
}
fn fast(mut options: XmodemOptions) -> XmodemOptions {
options.xmodem.crc_interval = Duration::from_millis(30);
options.xmodem.timeout = Duration::from_millis(60);
options.xmodem.byte_timeout = Duration::from_millis(30);
options.xmodem.purge = Duration::from_millis(20);
options.start_timeout = MIN_START_TIMEOUT;
options.drain = Duration::ZERO;
options
}
fn xmodem_part(trace: &str) -> &str {
let at = trace.find("# xmodem start").unwrap();
&trace[at..]
}
#[test]
fn receive_49g_payload_strips_garbage_padding() {
let transport = MemoryTransport::from_trace(xmodem_part(G49_XSEND_HPCRC)).unwrap();
let options = fast(XmodemOptions::for_model(Model::Hp49G).unwrap());
let mut s = XmodemSession::new(Box::new(transport), options);
let got = s.receive().unwrap();
assert_eq!(got.data, all_bytes(H49));
assert_eq!(got.check, Check::HpCrc);
assert_eq!((got.received, got.last_block), (384, 128));
assert_eq!(got.stripped, Some(384 - 269));
}
#[test]
fn allowance_is_one_less_than_a_block() {
let object = all_bytes(H49);
let mut raw = object.clone();
raw.extend(std::iter::repeat_n(0u8, 128));
assert_eq!(strip_padding(&raw, 127).len(), raw.len());
raw.pop();
assert_eq!(strip_padding(&raw, 127), &object[..]);
}
#[test]
fn receive_49g_checksum_payload() {
let transport = MemoryTransport::from_trace(xmodem_part(G49_XSEND)).unwrap();
let mut options = fast(XmodemOptions::default());
options.xmodem.check = Check::Crc16;
let mut s = XmodemSession::new(Box::new(transport), options);
let got = s.receive().unwrap();
assert_eq!(got.check, Check::Checksum);
assert_eq!(got.data, all_bytes(H49));
}
#[test]
fn receive_48gx_payload_strips_zero_padding() {
let transport = MemoryTransport::from_trace(xmodem_part(GX_XSEND)).unwrap();
let mut options = fast(XmodemOptions::for_model(Model::Hp48Gx).unwrap());
options.xmodem.check = Check::Crc16;
options.xmodem.crc_attempts = 3;
let mut s = XmodemSession::new(Box::new(transport), options);
let got = s.receive().unwrap();
assert_eq!(got.check, Check::Checksum);
assert_eq!(got.data, all_bytes(H48));
assert_eq!(got.stripped, Some(115));
}
#[test]
fn send_replays_recorded_xrecv() {
for (trace, header, model) in [
(G49_XRECV, H49, Model::Hp49G),
(GX_XRECV, H48, Model::Hp48Gx),
] {
let transport = MemoryTransport::from_trace(xmodem_part(trace)).unwrap();
let mut options = fast(XmodemOptions::for_model(model).unwrap());
options.xmodem.pad = xmodem_proto::codec::SUB;
let mut s = XmodemSession::new(Box::new(transport), options);
let report = s.send(&all_bytes(header)).unwrap();
assert_eq!(report.bytes, 269);
}
}
#[test]
fn walk_failure_keeps_every_byte() {
let peer = FakeCalc::sender(b"plain text, no header".to_vec(), Behaviour::hp49());
let mut s = XmodemSession::new(
Box::new(peer.clone()),
fast(XmodemOptions::for_model(Model::Hp49G).unwrap()),
);
let got = s.receive().unwrap();
assert_eq!(got.stripped, None);
assert_eq!(got.data.len(), 128);
assert!(got.data.starts_with(b"plain text"));
}
#[test]
fn exact_object_reports_zero_stripped() {
let peer = FakeCalc::sender(
hp_string(H49, &[b'x'; 128 - HEADER_LEN - 5]),
Behaviour::hp49(),
);
let mut s = XmodemSession::new(
Box::new(peer),
fast(XmodemOptions::for_model(Model::Hp49G).unwrap()),
);
let got = s.receive().unwrap();
assert_eq!(got.received, 128);
assert_eq!(got.stripped, Some(0));
}
#[derive(Clone, Debug)]
struct Behaviour {
start: u8,
answers: Vec<u8>,
accepts_1k: bool,
pad: Option<u8>,
drop_block: Option<u8>,
corrupt_block: Option<u8>,
}
impl Behaviour {
fn hp49() -> Self {
Behaviour {
start: b'D',
answers: vec![b'D', NAK],
accepts_1k: true,
pad: None,
drop_block: None,
corrupt_block: None,
}
}
fn hp48gx() -> Self {
Behaviour {
start: NAK,
answers: vec![NAK],
accepts_1k: false,
pad: Some(0),
drop_block: None,
corrupt_block: None,
}
}
}
#[derive(Default, Debug)]
struct State {
readable: VecDeque<u8>,
received: Vec<u8>,
blk: u8,
rejected: u32,
done: bool,
started: bool,
pos: usize,
eot: bool,
mangled: Vec<u8>,
written: Vec<Vec<u8>>,
check: Option<Check>,
cans: Vec<u8>,
}
#[derive(Clone)]
struct FakeCalc {
file: Option<Vec<u8>>,
behaviour: Behaviour,
state: Arc<Mutex<State>>,
}
impl FakeCalc {
fn receiver(behaviour: Behaviour) -> Self {
let state = State {
readable: VecDeque::from([behaviour.start]),
blk: 1,
check: Check::from_start_char(behaviour.start),
..State::default()
};
FakeCalc {
file: None,
behaviour,
state: Arc::new(Mutex::new(state)),
}
}
fn sender(file: Vec<u8>, behaviour: Behaviour) -> Self {
let state = State {
blk: 1,
..State::default()
};
FakeCalc {
file: Some(file),
behaviour,
state: Arc::new(Mutex::new(state)),
}
}
fn state(&self) -> std::sync::MutexGuard<'_, State> {
self.state.lock().unwrap()
}
fn current(&self, st: &mut State) -> Vec<u8> {
let file = self.file.as_deref().unwrap_or_default();
if st.pos >= file.len() {
st.eot = true;
return vec![EOT];
}
let check = st.check.unwrap_or(Check::Checksum);
let end = (st.pos + 128).min(file.len());
let mut data = file[st.pos..end].to_vec();
let fill = |i: usize| match self.behaviour.pad {
Some(p) => p,
None => (i * 37 + 11) as u8,
};
while data.len() < 128 {
data.push(fill(data.len()));
}
let mut block = encode_block(st.blk, BlockSize::B128, &data, 0, check).unwrap();
if self.behaviour.corrupt_block == Some(st.blk) && !st.mangled.contains(&st.blk) {
st.mangled.push(st.blk);
block[10] ^= 0xFF;
}
if self.behaviour.drop_block == Some(st.blk) && !st.mangled.contains(&st.blk) {
st.mangled.push(st.blk);
return Vec::new();
}
block
}
fn on_write(&self, bytes: &[u8]) {
let mut st = self.state();
st.written.push(bytes.to_vec());
if self.file.is_some() {
self.on_write_as_sender(&mut st, bytes);
} else {
self.on_write_as_receiver(&mut st, bytes);
}
}
fn on_write_as_sender(&self, st: &mut State, bytes: &[u8]) {
if bytes.contains(&CAN) {
st.cans.extend(bytes.iter().filter(|&&b| b == CAN));
st.done = true;
return;
}
for &b in bytes {
if !st.started {
if self.behaviour.answers.contains(&b) {
st.started = true;
st.check = Check::from_start_char(b);
let block = self.current(st);
st.readable.extend(block);
}
continue;
}
match b {
ACK if st.eot => st.done = true,
ACK => {
st.pos += 128;
st.blk = st.blk.wrapping_add(1);
let block = self.current(st);
st.readable.extend(block);
}
NAK => {
let block = self.current(st);
st.readable.extend(block);
}
_ => {}
}
}
}
fn on_write_as_receiver(&self, st: &mut State, bytes: &[u8]) {
let check = st.check.unwrap_or(Check::Checksum);
match bytes.first() {
Some(&EOT) => {
st.done = true;
st.readable.push_back(ACK);
}
Some(&CAN) => {
st.cans.extend_from_slice(bytes);
st.done = true;
}
Some(&STX) if !self.behaviour.accepts_1k => {
st.rejected += 1;
if st.rejected >= 9 {
st.readable.extend([CAN, CAN, CAN]);
} else {
st.readable.push_back(NAK);
}
}
Some(&(SOH | STX)) => {
let num = bytes.get(1).copied().unwrap_or_default();
if self.behaviour.drop_block == Some(num) && !st.mangled.contains(&num) {
st.mangled.push(num);
return;
}
match decode_block(bytes, check) {
Ok(block) if block.num == st.blk => {
st.received.extend_from_slice(&block.data);
st.blk = st.blk.wrapping_add(1);
st.readable.push_back(ACK);
}
Ok(_) => st.readable.push_back(ACK),
Err(_) => st.readable.push_back(NAK),
}
}
_ => {}
}
}
}
impl Transport for FakeCalc {
fn write_packet(&mut self, packet: &[u8]) -> io::Result<()> {
self.on_write(packet);
Ok(())
}
fn read(&mut self, buf: &mut [u8], timeout: Duration) -> io::Result<usize> {
let mut st = self.state();
if st.readable.is_empty() {
drop(st);
std::thread::sleep(timeout.min(Duration::from_millis(20)));
return Ok(0);
}
let n = st.readable.len().min(buf.len());
for (slot, byte) in buf.iter_mut().zip(st.readable.drain(..n)) {
*slot = byte;
}
Ok(n)
}
}
struct LostAfterDone(FakeCalc);
impl Transport for LostAfterDone {
fn write_packet(&mut self, packet: &[u8]) -> io::Result<()> {
self.0.write_packet(packet)
}
fn read(&mut self, buf: &mut [u8], timeout: Duration) -> io::Result<usize> {
if self.0.state().done {
return Err(io::Error::other("link lost"));
}
self.0.read(buf, timeout)
}
}
#[test]
fn link_lost_while_lingering_keeps_the_file() {
let file = all_bytes(H49);
let peer = FakeCalc::sender(file.clone(), Behaviour::hp49());
let mut options = fast(XmodemOptions::for_model(Model::Hp49G).unwrap());
options.xmodem.linger = Duration::from_secs(5);
let mut s = XmodemSession::new(Box::new(LostAfterDone(peer.clone())), options);
let start = Instant::now();
let got = s.receive().unwrap();
assert_eq!(got.data, file);
assert!(peer.state().done);
assert!(
start.elapsed() < Duration::from_secs(5),
"linger ended early"
);
}
fn big_file(header: &[u8; 8]) -> Vec<u8> {
hp_string(header, &(0..1811).map(|i| i as u8).collect::<Vec<u8>>())
}
#[test]
fn send_to_49g_uses_hp_crc_and_1k() {
let peer = FakeCalc::receiver(Behaviour::hp49());
let options = fast(XmodemOptions::for_model(Model::Hp49G).unwrap());
let mut s = XmodemSession::new(Box::new(peer.clone()), options);
let file = big_file(H49);
let mut events = Vec::new();
let report = s.send_with(&file, &mut |e| events.push(e.clone())).unwrap();
assert_eq!(report.check, Check::HpCrc);
assert_eq!(report.bytes, file.len() as u64);
let st = peer.state();
assert!(st.done);
assert_eq!(&st.received[..file.len()], file.as_slice());
assert_eq!(st.written[0][0], STX);
assert!(st.written[1..].iter().all(|w| w[0] != STX));
assert!(events.contains(&Event::Done));
}
#[test]
fn send_to_48gx_uses_checksum_and_128_byte_blocks() {
let peer = FakeCalc::receiver(Behaviour::hp48gx());
let mut options = fast(XmodemOptions::default());
options.xmodem.block_size = BlockSize::B1k;
let mut s = XmodemSession::new(Box::new(peer.clone()), options);
let file = big_file(H48);
let report = s.send(&file).unwrap();
assert_eq!(report.check, Check::Checksum);
let st = peer.state();
assert_eq!(st.rejected, 0);
assert_eq!(&st.received[..file.len()], file.as_slice());
assert!(st.written.iter().all(|w| w[0] != STX));
}
#[test]
fn send_1k_forced_on_48gx_is_cancelled() {
let peer = FakeCalc::receiver(Behaviour::hp48gx());
let mut options = fast(XmodemOptions::default());
options.xmodem.checksum_1k = true;
let mut s = XmodemSession::new(Box::new(peer.clone()), options);
let err = s.send(&big_file(H48)).unwrap_err();
assert!(
matches!(err, Error::Xmodem(xmodem_proto::Error::RemoteCancelled)),
"{err:?}"
);
assert_eq!(peer.state().rejected, 9);
}
#[test]
fn send_recovers_a_dropped_block() {
let peer = FakeCalc::receiver(Behaviour {
drop_block: Some(2),
..Behaviour::hp48gx()
});
let mut s = XmodemSession::new(
Box::new(peer.clone()),
fast(XmodemOptions::for_model(Model::Hp48Gx).unwrap()),
);
let file = all_bytes(H48);
s.send(&file).unwrap();
let st = peer.state();
assert_eq!(&st.received[..file.len()], file.as_slice());
let twos = st
.written
.iter()
.filter(|w| w.first() == Some(&SOH) && w.get(1) == Some(&2))
.count();
assert_eq!(twos, 2);
}
#[test]
fn receive_from_49g_recovers_dropped_and_corrupt_blocks() {
let file = big_file(H49);
let peer = FakeCalc::sender(
file.clone(),
Behaviour {
drop_block: Some(3),
corrupt_block: Some(5),
..Behaviour::hp49()
},
);
let mut s = XmodemSession::new(
Box::new(peer.clone()),
fast(XmodemOptions::for_model(Model::Hp49G).unwrap()),
);
let got = s.receive().unwrap();
assert_eq!(got.check, Check::HpCrc);
assert_eq!(got.data, file);
let st = peer.state();
assert!(st.done);
assert_eq!(st.mangled, vec![3, 5]);
assert!(st.written.iter().filter(|w| **w == [NAK]).count() >= 2);
}
#[test]
fn receive_from_48gx_ignores_d_and_uses_checksum() {
let file = all_bytes(H48);
let peer = FakeCalc::sender(file.clone(), Behaviour::hp48gx());
let mut options = fast(XmodemOptions::default());
options.xmodem.crc_attempts = 3;
let mut s = XmodemSession::new(Box::new(peer.clone()), options);
let got = s.receive().unwrap();
assert_eq!(got.check, Check::Checksum);
assert_eq!(got.data, file);
let st = peer.state();
assert_eq!(
&st.written[..4],
&[b"D".to_vec(), b"D".to_vec(), b"D".to_vec(), vec![NAK]]
);
}
#[test]
fn nobody_starts_send_times_out() {
let peer = FakeCalc::receiver(Behaviour {
start: 0,
..Behaviour::hp49()
});
peer.state().readable.clear();
let mut s = XmodemSession::new(
Box::new(peer),
fast(XmodemOptions::for_model(Model::Hp49G).unwrap()),
);
let start = Instant::now();
let err = s.send(b"x").unwrap_err();
assert!(
matches!(err, Error::Xmodem(xmodem_proto::Error::Timeout)),
"{err:?}"
);
let took = start.elapsed();
assert!(
took >= MIN_START_TIMEOUT && took < Duration::from_secs(3),
"{took:?}"
);
}
#[test]
fn nobody_starts_receive_times_out_with_cans() {
let peer = FakeCalc::sender(
b"x".to_vec(),
Behaviour {
answers: vec![],
..Behaviour::hp49()
},
);
let mut s = XmodemSession::new(
Box::new(peer.clone()),
fast(XmodemOptions::for_model(Model::Hp49G).unwrap()),
);
let start = Instant::now();
let err = s.receive().unwrap_err();
assert!(
matches!(err, Error::Xmodem(xmodem_proto::Error::Timeout)),
"{err:?}"
);
let took = start.elapsed();
assert!(
took >= MIN_START_TIMEOUT && took < Duration::from_secs(3),
"{took:?}"
);
let st = peer.state();
assert!(st.written.len() > 3);
assert!(
st.written[..st.written.len() - 1]
.iter()
.all(|w| *w == b"D")
);
assert_eq!(st.cans, vec![CAN, CAN, CAN]);
}
struct NoisyLine {
reads: usize,
first: Option<Vec<u8>>,
}
impl Transport for NoisyLine {
fn write_packet(&mut self, _packet: &[u8]) -> io::Result<()> {
Ok(())
}
fn read(&mut self, buf: &mut [u8], _timeout: Duration) -> io::Result<usize> {
self.reads += 1;
if self.reads > 20_000 {
return Err(io::Error::other("read cap hit: watchdog never fired"));
}
if let Some(block) = self.first.take() {
buf[..block.len()].copy_from_slice(&block);
return Ok(block.len());
}
std::thread::sleep(Duration::from_millis(1));
let noise = [SOH, 2, 0xFD, 7, 7, 7];
buf[..noise.len()].copy_from_slice(&noise);
Ok(noise.len())
}
}
#[test]
fn continuous_noise_still_ends() {
let mut options = fast(XmodemOptions::default());
options.xmodem.retries = 1;
let first = encode_block(1, BlockSize::B128, b"x", 0, Check::HpCrc).unwrap();
let line = NoisyLine {
reads: 0,
first: Some(first),
};
let mut s = XmodemSession::new(Box::new(line), options);
let start = Instant::now();
let err = s.receive().unwrap_err();
assert!(
matches!(err, Error::Xmodem(xmodem_proto::Error::Timeout)),
"{err:?}"
);
assert!(
start.elapsed() < Duration::from_secs(5),
"{:?}",
start.elapsed()
);
}
#[test]
fn options_for_models() {
assert!(matches!(
XmodemOptions::for_model(Model::Hp48Sx),
Err(Error::Unsupported(_))
));
let gx = XmodemOptions::for_model(Model::Hp48Gx).unwrap();
assert_eq!(
(gx.xmodem.check, gx.xmodem.block_size),
(Check::Checksum, BlockSize::B128)
);
let g49 = XmodemOptions::for_model(Model::Hp49G).unwrap();
assert_eq!(
(g49.xmodem.check, g49.xmodem.block_size),
(Check::HpCrc, BlockSize::B1k)
);
let clamp = XmodemOptions {
start_timeout: Duration::from_secs(100_000),
..XmodemOptions::default()
};
assert_eq!(clamp.config().start_timeout, MAX_START_TIMEOUT);
assert_eq!(clamp.config().recv_start_timeout, Some(MAX_START_TIMEOUT));
let zero = XmodemOptions {
start_timeout: Duration::ZERO,
..XmodemOptions::default()
};
assert_eq!(zero.config().start_timeout, MIN_START_TIMEOUT);
}
}