mod banner;
mod handshake;
mod reader;
mod registry;
mod stream;
pub use banner::{Banner, HOST_FEATURES};
pub use handshake::{Negotiated, handshake};
pub use stream::Stream;
use crate::auth::HostKey;
use crate::channel::Connection;
use crate::error::{Error, Result};
use crate::transport::Transport;
use crate::wire::{Command, Message};
use registry::Registry;
use std::sync::Arc;
use std::time::Duration;
use stream::Outbox;
use tokio::sync::mpsc::unbounded_channel;
use tokio::task::JoinHandle;
pub struct Session {
negotiated: Negotiated,
registry: Arc<Registry>,
outbox: Outbox,
reader: JoinHandle<Error>,
writer: JoinHandle<()>,
}
impl std::fmt::Debug for Session {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Session")
.field("banner", &self.negotiated.banner)
.field("max_payload", &self.negotiated.max_payload)
.field("streams", &self.registry.len())
.finish_non_exhaustive()
}
}
impl Session {
pub async fn connect<T: Transport>(
mut transport: T,
key: &HostKey,
auth_wait: Duration,
) -> Result<Self> {
let negotiated = handshake(&mut transport, key, auth_wait).await?;
Ok(Self::start(transport, negotiated))
}
pub fn start<T: Transport>(transport: T, negotiated: Negotiated) -> Self {
let (sink, source) = transport.split();
let registry = Arc::new(Registry::new());
let (outbox, outbox_rx) = unbounded_channel();
let reader = tokio::spawn(reader::read_loop(
source,
Arc::clone(®istry),
outbox.clone(),
));
let writer = tokio::spawn(reader::write_loop(sink, outbox_rx));
Self {
negotiated,
registry,
outbox,
reader,
writer,
}
}
pub fn banner(&self) -> &Banner {
&self.negotiated.banner
}
pub fn negotiated(&self) -> &Negotiated {
&self.negotiated
}
pub fn max_payload(&self) -> u32 {
self.negotiated.max_payload
}
pub async fn open_stream(&self, service: &str) -> Result<Stream> {
if service.contains('\0') {
return Err(Error::InvalidArgument("service name contains NUL".into()));
}
let (state, data_rx) = self.registry.register();
let mut payload = service.as_bytes().to_vec();
payload.push(0);
self.outbox
.send(Message::new(Command::Open, state.local_id, 0, payload))
.map_err(|_| Error::Disconnected)?;
if !state.wait_ack(0).await || state.remote().is_none() {
self.registry.remove(state.local_id);
return Err(Error::ServiceRefused {
service: service.to_owned(),
});
}
Ok(Stream::new(
state,
data_rx,
self.outbox.clone(),
Arc::clone(&self.registry),
self.max_payload(),
))
}
pub fn is_alive(&self) -> bool {
!self.reader.is_finished() && !self.writer.is_finished()
}
pub fn close(&self) {
self.registry.close_all();
self.reader.abort();
self.writer.abort();
}
}
impl Drop for Session {
fn drop(&mut self) {
self.close();
}
}
impl Connection for Session {
type Channel = Stream;
fn open(&self, service: &str) -> impl Future<Output = Result<Stream>> + Send {
self.open_stream(service)
}
fn features(&self) -> impl Future<Output = Result<Vec<String>>> + Send {
std::future::ready(Ok(self.negotiated.banner.features.clone()))
}
}