use std::net::SocketAddr;
use std::sync::Arc;
use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
use http::Uri;
use tokio::net::{TcpListener, TcpStream};
use crate::rpc::{CallError, ErrorCode, Frame};
use crate::types::Identity;
use crate::version::{Subprotocol, Version};
use super::TransportError;
use super::connection::Keepalive;
use super::stream::MaybeTls;
use super::ws::WsError;
use super::ws::handshake::{
ClientRequest, client_handshake, read_request, write_accept, write_refusal,
};
use super::ws::{
CloseCode, CloseFrame, Config as WsConfig, Message, Role as WsRole, WebSocket, WsCodec,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Direction {
Northbound,
Southbound,
}
#[derive(Clone, Debug)]
#[non_exhaustive]
#[must_use = "discarding the decision forwards the frame, which is the opposite of `Reject`"]
pub enum RelayDecision {
Forward,
Reject(CallError),
Drop,
Replace(String),
}
pub trait Relay: Send + Sync + 'static {
fn inspect(
&self,
identity: &Identity,
direction: Direction,
frame: &Frame<'_>,
) -> RelayDecision;
}
pub struct PassThrough;
impl Relay for PassThrough {
fn inspect(&self, _: &Identity, _: Direction, _: &Frame<'_>) -> RelayDecision {
RelayDecision::Forward
}
}
impl<F> Relay for F
where
F: Fn(&Identity, Direction, &Frame<'_>) -> RelayDecision + Send + Sync + 'static,
{
fn inspect(
&self,
identity: &Identity,
direction: Direction,
frame: &Frame<'_>,
) -> RelayDecision {
self(identity, direction, frame)
}
}
#[derive(Clone, Debug, Default)]
#[non_exhaustive]
pub enum UpstreamCredentials {
#[default]
PassThrough,
None,
}
pub struct LocalControllerBuilder {
bind: Option<SocketAddr>,
upstream: Option<String>,
#[cfg(feature = "rustls")]
server_tls: Option<super::tls::ServerTls>,
#[cfg(feature = "rustls")]
client_tls: Option<super::tls::ClientTls>,
relay: Arc<dyn Relay>,
credentials: UpstreamCredentials,
versions: Option<Subprotocol>,
ws_config: WsConfig,
#[cfg(feature = "compression")]
compression: bool,
connect_timeout: Duration,
keepalive: Keepalive,
}
impl Default for LocalControllerBuilder {
fn default() -> Self {
Self {
bind: None,
upstream: None,
#[cfg(feature = "rustls")]
server_tls: None,
#[cfg(feature = "rustls")]
client_tls: None,
relay: Arc::new(PassThrough),
credentials: UpstreamCredentials::default(),
versions: None,
ws_config: WsConfig::default(),
#[cfg(feature = "compression")]
compression: true,
connect_timeout: Duration::from_secs(20),
keepalive: Keepalive::default(),
}
}
}
impl LocalControllerBuilder {
#[must_use]
pub fn bind(mut self, addr: SocketAddr) -> Self {
self.bind = Some(addr);
self
}
#[must_use]
pub fn upstream(mut self, url: impl Into<String>) -> Self {
self.upstream = Some(url.into());
self
}
#[cfg(feature = "rustls")]
#[must_use]
pub fn server_tls(mut self, tls: super::tls::ServerTls) -> Self {
self.server_tls = Some(tls);
self
}
#[cfg(feature = "rustls")]
#[must_use]
pub fn client_tls(mut self, tls: super::tls::ClientTls) -> Self {
self.client_tls = Some(tls);
self
}
#[cfg(feature = "compression")]
#[must_use]
pub fn compression(mut self, enabled: bool) -> Self {
self.compression = enabled;
self
}
#[must_use]
pub fn relay(mut self, relay: impl Relay) -> Self {
self.relay = Arc::new(relay);
self
}
#[must_use]
pub fn upstream_credentials(mut self, credentials: UpstreamCredentials) -> Self {
self.credentials = credentials;
self
}
#[must_use]
pub fn keepalive(mut self, keepalive: Keepalive) -> Self {
self.keepalive = keepalive;
self
}
#[must_use]
pub fn versions(mut self, versions: impl IntoIterator<Item = Version>) -> Self {
self.versions = Some(Subprotocol::new(versions));
self
}
pub fn build(self) -> Result<LocalController, TransportError> {
let bind = self
.bind
.ok_or_else(|| TransportError::Configuration("bind address is required".into()))?;
let upstream = self
.upstream
.ok_or_else(|| TransportError::Configuration("upstream URL is required".into()))?;
Ok(LocalController {
bind,
upstream,
#[cfg(feature = "rustls")]
server_tls: self.server_tls,
#[cfg(feature = "rustls")]
client_tls: self.client_tls,
relay: self.relay,
credentials: self.credentials,
versions: self.versions,
ws_config: self.ws_config,
#[cfg(feature = "compression")]
compression: self.compression,
connect_timeout: self.connect_timeout,
keepalive: self.keepalive,
})
}
}
pub struct LocalController {
bind: SocketAddr,
upstream: String,
#[cfg(feature = "rustls")]
server_tls: Option<super::tls::ServerTls>,
#[cfg(feature = "rustls")]
client_tls: Option<super::tls::ClientTls>,
relay: Arc<dyn Relay>,
credentials: UpstreamCredentials,
versions: Option<Subprotocol>,
ws_config: WsConfig,
#[cfg(feature = "compression")]
compression: bool,
connect_timeout: Duration,
keepalive: Keepalive,
}
impl LocalController {
#[must_use]
pub fn builder() -> LocalControllerBuilder {
LocalControllerBuilder::default()
}
pub async fn serve(self) -> Result<(), TransportError> {
let listener = TcpListener::bind(self.bind).await?;
self.serve_on(listener).await
}
pub async fn serve_on(self, listener: TcpListener) -> Result<(), TransportError> {
let controller = Arc::new(self);
loop {
let (stream, remote) = listener.accept().await?;
let controller = controller.clone();
tokio::spawn(async move {
if let Err(error) = controller.attach(stream, remote).await {
#[cfg(feature = "tracing")]
tracing::debug!(%remote, %error, "station connection ended");
let _ = (error, remote);
}
});
}
}
async fn attach(
self: Arc<Self>,
stream: TcpStream,
remote: SocketAddr,
) -> Result<(), TransportError> {
stream.set_nodelay(true)?;
let mut south = self.wrap_server(stream).await?;
let request = read_request(&mut south).await?;
if let Some(defect) = request.upgrade_defect() {
let (status, reason) = defect.status();
let _ = write_refusal(&mut south, status, reason).await;
return Ok(());
}
let Some(identity) = request.identity() else {
let _ = write_refusal(&mut south, 400, "Bad Request").await;
return Ok(());
};
let offered = Subprotocol::new(request.subprotocols());
let northbound_offer = match &self.versions {
Some(limit) => Subprotocol::new(
offered
.offered()
.iter()
.copied()
.filter(|v| limit.offered().contains(v)),
),
None => offered.clone(),
};
let authorization = request.header("authorization").map(ToOwned::to_owned);
let north = tokio::time::timeout(
self.connect_timeout,
self.connect_upstream(&identity, &northbound_offer, authorization.as_deref()),
)
.await
.map_err(|_| TransportError::Configuration("upstream connect timed out".into()))?;
let (north, version) = match north {
Ok(pair) => pair,
Err(error) => {
let _ = write_refusal(&mut south, 502, "Bad Gateway").await;
return Err(error);
}
};
#[allow(unused_mut)]
let mut codec = WsCodec::new(WsRole::Server, self.ws_config);
#[allow(unused_mut)]
let mut extensions: Option<String> = None;
#[cfg(feature = "compression")]
if self.compression {
if let Some((params, response)) =
super::ws::deflate::accept_offer(request.extensions().as_deref())
{
codec = codec.with_deflate(params);
extensions = Some(response);
}
}
write_accept(
&mut south,
request.websocket_key().unwrap_or_default(),
Some(version.subprotocol()),
extensions.as_deref(),
)
.await?;
let south = super::ws::attach(south, codec, &request.head.rest);
#[cfg(feature = "tracing")]
tracing::info!(identity = %identity, %remote, %version, "station attached");
let _ = remote;
self.pump(identity, version, south, north).await
}
async fn wrap_server(&self, stream: TcpStream) -> Result<MaybeTls, TransportError> {
#[cfg(feature = "rustls")]
if let Some(tls) = &self.server_tls {
return Ok(MaybeTls::ServerTls(Box::new(
tls.acceptor().accept(stream).await?,
)));
}
Ok(MaybeTls::Plain(stream))
}
async fn connect_upstream(
&self,
identity: &Identity,
offer: &Subprotocol,
authorization: Option<&str>,
) -> Result<(WebSocket<MaybeTls>, Version), TransportError> {
let uri: Uri = self
.upstream
.parse()
.map_err(|_| TransportError::Url(self.upstream.clone()))?;
let secure = matches!(uri.scheme_str(), Some("wss" | "https"));
let host = uri
.host()
.ok_or_else(|| TransportError::Url(self.upstream.clone()))?
.to_owned();
let port = uri.port_u16().unwrap_or(if secure { 443 } else { 80 });
let tcp = TcpStream::connect((host.as_str(), port)).await?;
tcp.set_nodelay(true)?;
let mut stream = if secure {
#[cfg(feature = "rustls")]
{
let tls = self.client_tls.as_ref().ok_or_else(|| {
TransportError::Configuration("a wss upstream needs client_tls".into())
})?;
let name = super::tls::ClientTls::server_name(&host)
.map_err(|error| TransportError::Configuration(error.to_string()))?;
MaybeTls::ClientTls(Box::new(tls.connector().connect(name, tcp).await?))
}
#[cfg(not(feature = "rustls"))]
return Err(TransportError::Configuration(
"TLS needs the `rustls` feature".into(),
));
} else {
MaybeTls::Plain(tcp)
};
let path = format!(
"{}/{}",
uri.path().trim_end_matches('/'),
super::ws::handshake::percent_encode(identity.as_str())
);
let authority = if uri.port().is_some() {
format!("{host}:{port}")
} else {
host.clone()
};
let authorization = match (&self.credentials, authorization) {
(UpstreamCredentials::PassThrough, value) => value,
(UpstreamCredentials::None, _) => None,
};
#[allow(unused_mut)]
let mut extensions: Option<String> = None;
#[cfg(feature = "compression")]
if self.compression {
extensions = Some(super::ws::deflate::DeflateParams::default().client_offer());
}
let handshake = client_handshake(
&mut stream,
&ClientRequest {
host: &authority,
path: &path,
subprotocols: &offer.header_value(),
authorization,
extensions: extensions.as_deref(),
},
)
.await?;
let version = offer.accept(handshake.subprotocol.as_deref())?;
#[allow(unused_mut)]
let mut codec = WsCodec::new(WsRole::Client, self.ws_config);
#[cfg(feature = "compression")]
if extensions.is_some() {
if let Ok(Some(params)) =
super::ws::deflate::accept_response(handshake.extensions.as_deref())
{
codec = codec.with_deflate(params);
}
}
Ok((super::ws::attach(stream, codec, &handshake.rest), version))
}
async fn pump(
&self,
identity: Identity,
version: Version,
south: WebSocket<MaybeTls>,
north: WebSocket<MaybeTls>,
) -> Result<(), TransportError> {
let (mut south_tx, mut south_rx) = south.split();
let (mut north_tx, mut north_rx) = north.split();
let keepalive = self.keepalive;
let mut ping = keepalive.interval.map(|interval| {
let mut timer = tokio::time::interval(interval);
timer.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
timer
});
let mut south_pong_due: Option<tokio::time::Instant> = None;
let mut north_pong_due: Option<tokio::time::Instant> = None;
loop {
tokio::select! {
message = south_rx.next() => {
let carry_on = self
.relay_one(
&identity,
version,
Direction::Northbound,
message,
&mut south_tx,
&mut north_tx,
&mut south_pong_due,
)
.await;
if !carry_on {
break;
}
}
message = north_rx.next() => {
let carry_on = self
.relay_one(
&identity,
version,
Direction::Southbound,
message,
&mut north_tx,
&mut south_tx,
&mut north_pong_due,
)
.await;
if !carry_on {
break;
}
}
_ = async { ping.as_mut().expect("checked").tick().await }, if ping.is_some() => {
let deadline = tokio::time::Instant::now() + keepalive.timeout;
south_pong_due.get_or_insert(deadline);
north_pong_due.get_or_insert(deadline);
if south_tx.send(Message::Ping(Vec::new())).await.is_err()
|| north_tx.send(Message::Ping(Vec::new())).await.is_err()
{
break;
}
}
() = async { tokio::time::sleep_until(south_pong_due.expect("checked")).await },
if south_pong_due.is_some() =>
{
#[cfg(feature = "tracing")]
tracing::debug!(identity = %identity, "the station stopped answering pings");
break;
}
() = async { tokio::time::sleep_until(north_pong_due.expect("checked")).await },
if north_pong_due.is_some() =>
{
#[cfg(feature = "tracing")]
tracing::debug!(identity = %identity, "the CSMS stopped answering pings");
break;
}
}
}
let _ = south_tx
.send(Message::Close(Some(CloseFrame::new(
CloseCode::GOING_AWAY,
"",
))))
.await;
let _ = north_tx
.send(Message::Close(Some(CloseFrame::new(
CloseCode::GOING_AWAY,
"",
))))
.await;
let _ = south_tx.close().await;
let _ = north_tx.close().await;
#[cfg(feature = "tracing")]
tracing::info!(identity = %identity, "station detached");
Ok(())
}
#[allow(clippy::too_many_arguments)]
async fn relay_one<From, To>(
&self,
identity: &Identity,
version: Version,
direction: Direction,
message: Option<Result<Message, WsError>>,
from: &mut From,
to: &mut To,
pong_due: &mut Option<tokio::time::Instant>,
) -> bool
where
From: futures_util::Sink<Message, Error = WsError> + Unpin,
To: futures_util::Sink<Message, Error = WsError> + Unpin,
{
match message {
Some(Ok(Message::Text(text))) => match self.decide(identity, direction, &text, version)
{
Relayed::Forward(text) => to.send(Message::Text(text)).await.is_ok(),
Relayed::Answer(text) => from.send(Message::Text(text)).await.is_ok(),
Relayed::Drop => true,
},
Some(Ok(Message::Ping(payload))) => from.send(Message::Pong(payload)).await.is_ok(),
Some(Ok(Message::Pong(_))) => {
*pong_due = None;
true
}
Some(Ok(Message::Close(frame))) => {
let _ = to.send(Message::Close(frame)).await;
false
}
Some(Ok(Message::Binary(_))) => true,
Some(Err(error)) => {
#[cfg(feature = "tracing")]
tracing::debug!(identity = %identity, %error, "relay leg failed");
let _ = error;
false
}
None => false,
}
}
fn decide(
&self,
identity: &Identity,
direction: Direction,
text: &str,
version: Version,
) -> Relayed {
let Ok(frame) = Frame::parse(text, version) else {
return Relayed::Forward(text.to_owned());
};
match self.relay.inspect(identity, direction, &frame) {
RelayDecision::Forward => Relayed::Forward(text.to_owned()),
RelayDecision::Replace(text) => Relayed::Forward(text),
RelayDecision::Drop => Relayed::Drop,
RelayDecision::Reject(error) => match &frame {
Frame::Call { id, .. } => {
let answer = Frame::CallError {
id: id.clone(),
error: (&error).into(),
};
answer
.to_json(version)
.map_or(Relayed::Drop, Relayed::Answer)
}
_ => Relayed::Drop,
},
}
}
}
enum Relayed {
Forward(String),
Answer(String),
Drop,
}
pub struct RefuseActions {
actions: Vec<String>,
}
impl RefuseActions {
#[must_use]
pub fn new(actions: impl IntoIterator<Item = impl Into<String>>) -> Self {
Self {
actions: actions.into_iter().map(Into::into).collect(),
}
}
}
impl Relay for RefuseActions {
fn inspect(&self, _: &Identity, _: Direction, frame: &Frame<'_>) -> RelayDecision {
match frame.action() {
Some(action) if self.actions.iter().any(|a| a == action) => RelayDecision::Reject(
CallError::new(ErrorCode::NotSupported, "handled by the local controller"),
),
_ => RelayDecision::Forward,
}
}
}