use std::collections::VecDeque;
use std::io;
use std::time::Duration;
pub mod hdlc;
pub mod wrapper;
pub trait PhysicalTransport {
fn send(&mut self, data: &[u8]) -> io::Result<()>;
fn receive(&mut self, buf: &mut [u8]) -> io::Result<usize>;
fn set_read_timeout(&mut self, timeout: Option<Duration>) -> io::Result<()> {
let _ = timeout;
Ok(())
}
}
pub trait NetworkTransport: PhysicalTransport {}
pub trait DataLinkLayer {
fn send_apdu(&mut self, apdu: &[u8]) -> io::Result<()>;
fn receive_apdu(&mut self) -> io::Result<Vec<u8>>;
fn client_sap(&self) -> Option<u8> {
None
}
}
#[derive(Debug, Default)]
pub struct MemoryTransport {
buffer: VecDeque<u8>,
}
impl MemoryTransport {
pub fn new() -> Self {
MemoryTransport { buffer: VecDeque::new() }
}
pub fn buffered(&self) -> usize {
self.buffer.len()
}
pub fn feed(&mut self, data: &[u8]) {
self.buffer.extend(data.iter().copied());
}
}
impl PhysicalTransport for MemoryTransport {
fn send(&mut self, data: &[u8]) -> io::Result<()> {
self.buffer.extend(data.iter().copied());
Ok(())
}
fn receive(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let n = buf.len().min(self.buffer.len());
for slot in buf.iter_mut().take(n) {
*slot = self.buffer.pop_front().unwrap();
}
Ok(n)
}
}
impl NetworkTransport for MemoryTransport {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn memory_transport_round_trips_bytes() {
let mut t = MemoryTransport::new();
t.send(&[1, 2, 3, 4]).unwrap();
assert_eq!(t.buffered(), 4);
let mut buf = [0u8; 2];
assert_eq!(t.receive(&mut buf).unwrap(), 2);
assert_eq!(buf, [1, 2]);
assert_eq!(t.receive(&mut buf).unwrap(), 2);
assert_eq!(buf, [3, 4]);
assert_eq!(t.receive(&mut buf).unwrap(), 0);
}
}