use crate::error::Error;
use crate::pump::{PumpEvent, WindowedPump};
use crate::transport::ByteTransport;
use crate::tx::TxState;
use crate::window::MAX_WINDOW;
use super::session::{Capabilities, HandshakeError, PeerSession, SessionState, HELLO_LEN};
use super::table::{PeerTable, TableError};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LinkEvent {
Idle,
Progress,
Established,
Received(u8),
Closed,
Aborted,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LinkError<E> {
Transport(Error<E>),
Handshake(HandshakeError),
Table(TableError),
}
impl<E: core::fmt::Debug> core::fmt::Display for LinkError<E> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
LinkError::Transport(e) => write!(f, "transport: {e}"),
LinkError::Handshake(e) => write!(f, "handshake: {e}"),
LinkError::Table(e) => write!(f, "table: {e}"),
}
}
}
pub struct PeerLink<Tx, Rx>
where
Tx: ByteTransport,
Rx: ByteTransport<Error = Tx::Error>,
{
pump: WindowedPump<Tx, Rx, MAX_WINDOW>,
session: PeerSession,
slot: Option<usize>,
outgoing: [u8; HELLO_LEN],
out_at: usize,
out_len: usize,
incoming: [u8; HELLO_LEN],
in_len: usize,
need_start: bool,
initiator: bool,
established: bool,
announced: bool,
}
impl<Tx, Rx> PeerLink<Tx, Rx>
where
Tx: ByteTransport,
Rx: ByteTransport<Error = Tx::Error>,
{
pub fn connect<const N: usize>(
table: &mut PeerTable<N>,
mut pump: WindowedPump<Tx, Rx, MAX_WINDOW>,
) -> Result<Self, TableError> {
pump.set_window_limit(1);
let (slot, hello) = table.connect()?;
let session = match table.get(slot) {
Some(entry) => *entry.session(),
None => return Err(TableError::Empty),
};
Ok(PeerLink {
pump,
session,
slot: Some(slot),
outgoing: hello,
out_at: 0,
out_len: HELLO_LEN,
incoming: [0; HELLO_LEN],
in_len: 0,
need_start: true,
initiator: true,
established: false,
announced: false,
})
}
pub fn accept<const N: usize>(
table: &PeerTable<N>,
mut pump: WindowedPump<Tx, Rx, MAX_WINDOW>,
) -> Self {
pump.set_window_limit(1);
PeerLink {
pump,
session: PeerSession::new(table.local(), table.config()),
slot: None,
outgoing: [0; HELLO_LEN],
out_at: 0,
out_len: 0,
incoming: [0; HELLO_LEN],
in_len: 0,
need_start: false,
initiator: false,
established: false,
announced: false,
}
}
pub const fn session(&self) -> &PeerSession {
&self.session
}
pub const fn slot(&self) -> Option<usize> {
self.slot
}
pub fn pump(&self) -> &WindowedPump<Tx, Rx, MAX_WINDOW> {
&self.pump
}
pub fn pump_mut(&mut self) -> &mut WindowedPump<Tx, Rx, MAX_WINDOW> {
&mut self.pump
}
pub fn offer(&mut self, byte: u8) -> Result<(), Error<Tx::Error>> {
self.pump.sender_mut().offer(byte)
}
pub fn finish(&mut self) -> Result<(), Error<Tx::Error>> {
self.pump.sender_mut().offer_finish()
}
pub fn abort<const N: usize>(
&mut self,
table: &mut PeerTable<N>,
) -> Result<(), LinkError<Tx::Error>> {
self.pump.abort().map_err(LinkError::Transport)?;
self.session.abort();
self.sync(table);
Ok(())
}
fn sync<const N: usize>(&mut self, table: &mut PeerTable<N>) {
self.session.record_stats(self.pump.stats());
if let Some(slot) = self.slot {
let _ = table.store(slot, self.session);
}
}
fn apply_negotiated_window(&mut self) {
let Some(cfg) = self.session.negotiated() else {
return;
};
let limit = if cfg.features.contains(Capabilities::WINDOW) {
cfg.max_window as usize
} else {
1
};
self.pump.set_window_limit(limit);
}
fn offer_next(&mut self) -> Result<(), Error<Tx::Error>> {
if self.pump.sender().outstanding() != 0 || self.pump.sender().state() != TxState::Idle {
return Ok(());
}
if self.need_start {
self.pump.sender_mut().offer_start()?;
self.need_start = false;
return Ok(());
}
if self.out_at < self.out_len {
let byte = self.outgoing[self.out_at];
self.pump.sender_mut().offer(byte)?;
self.out_at += 1;
}
Ok(())
}
fn on_hello_byte<const N: usize>(
&mut self,
table: &mut PeerTable<N>,
byte: u8,
) -> Result<LinkEvent, LinkError<Tx::Error>> {
if self.in_len >= HELLO_LEN {
return Ok(LinkEvent::Progress);
}
self.incoming[self.in_len] = byte;
self.in_len += 1;
if self.in_len < HELLO_LEN {
return Ok(LinkEvent::Progress);
}
if self.initiator {
let slot = self.slot.ok_or(LinkError::Table(TableError::Empty))?;
table
.finish_connect(slot, &self.incoming)
.map_err(LinkError::Table)?;
if let Some(entry) = table.get(slot) {
self.session = *entry.session();
}
} else {
let (slot, reply) = table.accept(&self.incoming).map_err(LinkError::Table)?;
self.slot = Some(slot);
if let Some(entry) = table.get(slot) {
self.session = *entry.session();
}
self.outgoing = reply;
self.out_len = HELLO_LEN;
self.out_at = 0;
self.need_start = true;
}
self.established = self.session.state() == SessionState::Established;
if self.established {
self.apply_negotiated_window();
}
self.sync(table);
if self.established && self.initiator && !self.announced {
self.announced = true;
Ok(LinkEvent::Established)
} else {
Ok(LinkEvent::Progress)
}
}
pub fn poll<const N: usize>(
&mut self,
table: &mut PeerTable<N>,
) -> Result<LinkEvent, LinkError<Tx::Error>> {
self.offer_next().map_err(LinkError::Transport)?;
let ev = self.pump.poll().map_err(LinkError::Transport)?;
self.session.record_stats(self.pump.stats());
match ev {
PumpEvent::Aborted => {
self.session.abort();
self.sync(table);
Ok(LinkEvent::Aborted)
}
PumpEvent::Completed => {
self.session.closed();
self.sync(table);
Ok(LinkEvent::Closed)
}
PumpEvent::Received(byte) => {
if self.established {
Ok(LinkEvent::Received(byte))
} else {
self.on_hello_byte(table, byte)
}
}
PumpEvent::Idle => Ok(LinkEvent::Idle),
PumpEvent::Progress | PumpEvent::Sent => {
if !self.initiator
&& self.established
&& !self.announced
&& self.out_at >= self.out_len
&& !self.need_start
&& self.pump.sender().state() == TxState::Idle
&& self.pump.sender().outstanding() == 0
{
self.announced = true;
Ok(LinkEvent::Established)
} else {
Ok(LinkEvent::Progress)
}
}
}
}
}