use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;
use std::time::Duration;
use futures_util::SinkExt as _;
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::{Mutex, broadcast, mpsc, watch};
use crate::decode::DecodeOptions;
use crate::engine::{
BootState, CallFailure, CallOptions, Engine, EngineConfig, MemStore, RateLimit, Role,
};
use crate::message::{Confirmed, NoResponse, Request, Unconfirmed};
use crate::types::Identity;
use crate::version::{Subprotocol, Version};
use super::TransportError;
use super::connection::{
BoxFuture, DisconnectReason, Driver, Handle, Handler, Keepalive, SessionContext, SessionState,
Shared,
};
use super::security::{Credentials, SecurityProfile};
use super::stream::MaybeTls;
use super::ws::handshake::{read_request, write_accept, write_refusal};
use super::ws::{
CloseCode, CloseFrame, Config as WsConfig, Message, Role as WsRole, WebSocket, WsCodec,
};
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct Auth {
pub identity: Identity,
pub credentials: Credentials,
pub remote: SocketAddr,
pub profile: SecurityProfile,
pub path: String,
pub offered: Vec<Version>,
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum AuthOutcome {
Accept(SessionContext),
Reject,
Unknown,
}
impl AuthOutcome {
#[must_use]
pub const fn accept() -> Self {
Self::Accept(SessionContext::empty())
}
}
pub trait Authenticator: Send + Sync + 'static {
fn authenticate(&self, auth: Auth) -> BoxFuture<'_, AuthOutcome>;
}
impl<F, Fut> Authenticator for F
where
F: Fn(Auth) -> Fut + Send + Sync + 'static,
Fut: Future<Output = AuthOutcome> + Send + 'static,
{
fn authenticate(&self, auth: Auth) -> BoxFuture<'_, AuthOutcome> {
Box::pin(self(auth))
}
}
pub struct AcceptEveryStation;
impl Authenticator for AcceptEveryStation {
fn authenticate(&self, _auth: Auth) -> BoxFuture<'_, AuthOutcome> {
Box::pin(async { AuthOutcome::accept() })
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum SessionEvent {
Opened {
identity: Identity,
version: Version,
remote: SocketAddr,
compressed: bool,
},
Closed {
identity: Identity,
reason: DisconnectReason,
},
RateLimited {
identity: Identity,
},
Superseded {
identity: Identity,
},
Violation {
identity: Identity,
violation: crate::engine::ProtocolViolation,
},
Repaired {
identity: Identity,
action: String,
id: crate::types::MessageId,
repairs: Vec<crate::decode::Repair>,
},
Refused {
identity: Option<Identity>,
status: u16,
remote: SocketAddr,
},
}
pub struct CsmsBuilder {
bind: Option<SocketAddr>,
versions: Subprotocol,
#[cfg(feature = "rustls")]
tls: Option<super::tls::ServerTls>,
authenticator: Option<Arc<dyn Authenticator>>,
handler: Option<Arc<dyn Handler>>,
decode: Arc<dyn Fn(&Identity) -> DecodeOptions + Send + Sync>,
engine: Option<EngineConfig>,
max_connections: usize,
max_pending_handshakes: usize,
handshake_timeout: Duration,
keepalive: Keepalive,
ws_config: WsConfig,
#[cfg(feature = "compression")]
compression: bool,
supersede: bool,
supersede_drain: Duration,
message_rate: Option<RateLimit>,
idle_timeout: Option<Duration>,
}
impl Default for CsmsBuilder {
fn default() -> Self {
Self {
bind: None,
versions: Subprotocol::default(),
#[cfg(feature = "rustls")]
tls: None,
authenticator: None,
handler: None,
decode: Arc::new(|_| DecodeOptions::strict()),
engine: None,
max_connections: 10_000,
max_pending_handshakes: 512,
handshake_timeout: Duration::from_secs(15),
keepalive: Keepalive::default(),
ws_config: WsConfig::default(),
#[cfg(feature = "compression")]
compression: true,
supersede: true,
supersede_drain: Duration::from_secs(5),
message_rate: None,
idle_timeout: None,
}
}
}
impl CsmsBuilder {
#[must_use]
pub fn bind(mut self, addr: SocketAddr) -> Self {
self.bind = Some(addr);
self
}
#[must_use]
pub fn versions(mut self, versions: impl IntoIterator<Item = Version>) -> Self {
self.versions = Subprotocol::new(versions);
self
}
#[cfg(feature = "rustls")]
#[must_use]
pub fn tls(mut self, tls: super::tls::ServerTls) -> Self {
self.tls = Some(tls);
self
}
#[must_use]
pub fn authenticate(mut self, authenticator: impl Authenticator) -> Self {
self.authenticator = Some(Arc::new(authenticator));
self
}
#[must_use]
pub fn handler(mut self, handler: impl Handler) -> Self {
self.handler = Some(Arc::new(handler));
self
}
#[must_use]
pub fn decode_options_for(
mut self,
pick: impl Fn(&Identity) -> DecodeOptions + Send + Sync + 'static,
) -> Self {
self.decode = Arc::new(pick);
self
}
#[must_use]
pub fn max_message_size_bytes(mut self, bytes: usize) -> Self {
self.ws_config.max_message_size = bytes;
self.ws_config.max_frame_size = bytes;
self
}
#[cfg(feature = "compression")]
#[must_use]
pub fn compression(mut self, enabled: bool) -> Self {
self.compression = enabled;
self
}
#[must_use]
pub fn engine_config(mut self, config: EngineConfig) -> Self {
self.engine = Some(config);
self
}
#[must_use]
pub fn max_connections(mut self, max: usize) -> Self {
self.max_connections = max;
self
}
#[must_use]
pub fn ping_interval(mut self, interval: Option<Duration>) -> Self {
self.keepalive.interval = interval;
self
}
#[must_use]
pub fn keepalive(mut self, keepalive: Keepalive) -> Self {
self.keepalive = keepalive;
self
}
#[must_use]
pub fn max_pending_handshakes(mut self, max: usize) -> Self {
self.max_pending_handshakes = max.max(1);
self
}
#[must_use]
pub fn handshake_timeout(mut self, timeout: Duration) -> Self {
self.handshake_timeout = timeout;
self
}
#[must_use]
pub fn message_rate(mut self, rate: RateLimit) -> Self {
self.message_rate = Some(rate);
self
}
#[must_use]
pub fn idle_timeout(mut self, timeout: Duration) -> Self {
self.idle_timeout = Some(timeout);
self
}
#[must_use]
pub fn supersede_existing(mut self, supersede: bool) -> Self {
self.supersede = supersede;
self
}
#[must_use]
pub fn supersede_drain(mut self, deadline: Duration) -> Self {
self.supersede_drain = deadline;
self
}
pub fn build(self) -> Result<Csms, TransportError> {
let bind = self
.bind
.ok_or_else(|| TransportError::Configuration("bind address is required".into()))?;
let authenticator = self.authenticator.ok_or_else(|| {
TransportError::Configuration(
"an authenticator is required: call `authenticate(…)`, or \
`authenticate(AcceptEveryStation)` to accept every station on purpose"
.into(),
)
})?;
Ok(Csms {
bind,
versions: self.versions,
#[cfg(feature = "rustls")]
tls: self.tls,
authenticator,
handler: self
.handler
.unwrap_or_else(|| Arc::new(super::connection::NotImplemented)),
decode: self.decode,
engine: self.engine,
max_connections: self.max_connections,
handshake_timeout: self.handshake_timeout,
handshakes: Arc::new(tokio::sync::Semaphore::new(self.max_pending_handshakes)),
keepalive: self.keepalive,
ws_config: self.ws_config,
#[cfg(feature = "compression")]
compression: self.compression,
supersede: self.supersede,
supersede_drain: self.supersede_drain,
message_rate: self.message_rate,
idle_timeout: self.idle_timeout,
router: Arc::new(Router::default()),
events: broadcast::channel(1024).0,
})
}
}
#[derive(Default)]
struct Router {
sessions: Mutex<HashMap<Identity, Session>>,
next_session: std::sync::atomic::AtomicU64,
}
impl Router {
fn next_session_id(&self) -> u64 {
self.next_session
.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
}
}
struct Session {
id: u64,
handle: Handle,
task: tokio::task::JoinHandle<()>,
}
pub struct Csms {
bind: SocketAddr,
versions: Subprotocol,
#[cfg(feature = "rustls")]
tls: Option<super::tls::ServerTls>,
authenticator: Arc<dyn Authenticator>,
handler: Arc<dyn Handler>,
decode: Arc<dyn Fn(&Identity) -> DecodeOptions + Send + Sync>,
engine: Option<EngineConfig>,
max_connections: usize,
handshake_timeout: Duration,
handshakes: Arc<tokio::sync::Semaphore>,
keepalive: Keepalive,
ws_config: WsConfig,
#[cfg(feature = "compression")]
compression: bool,
supersede: bool,
supersede_drain: Duration,
message_rate: Option<RateLimit>,
idle_timeout: Option<Duration>,
router: Arc<Router>,
events: broadcast::Sender<SessionEvent>,
}
impl Csms {
#[must_use]
pub fn builder() -> CsmsBuilder {
CsmsBuilder::default()
}
#[must_use]
pub fn handle(&self) -> CsmsHandle {
CsmsHandle {
router: self.router.clone(),
events: self.events.clone(),
}
}
pub async fn serve(self) -> Result<(), TransportError> {
let listener = TcpListener::bind(self.bind).await?;
#[cfg(feature = "tracing")]
tracing::info!(address = ?listener.local_addr(), "CSMS listening");
self.serve_on(listener).await
}
pub async fn serve_on(self, listener: TcpListener) -> Result<(), TransportError> {
let server = Arc::new(self);
loop {
let (stream, remote) = listener.accept().await?;
let Ok(permit) = server.handshakes.clone().acquire_owned().await else {
continue;
};
let server = server.clone();
tokio::spawn(async move {
let timeout = server.handshake_timeout;
let outcome = tokio::time::timeout(timeout, server.accept(stream, remote)).await;
drop(permit);
match outcome {
Ok(Ok(())) => {}
Ok(Err(error)) => {
#[cfg(feature = "tracing")]
tracing::debug!(%remote, %error, "connection rejected");
let _ = error;
}
Err(_) => {
#[cfg(feature = "tracing")]
tracing::debug!(%remote, ?timeout, "handshake timed out");
}
}
});
}
}
#[must_use]
pub fn configured_addr(&self) -> SocketAddr {
self.bind
}
#[allow(clippy::too_many_lines)]
async fn accept(
self: Arc<Self>,
stream: TcpStream,
remote: SocketAddr,
) -> Result<(), TransportError> {
stream.set_nodelay(true)?;
let mut socket = if cfg!(feature = "rustls") {
#[cfg(feature = "rustls")]
match &self.tls {
Some(tls) => MaybeTls::ServerTls(Box::new(tls.acceptor().accept(stream).await?)),
None => MaybeTls::Plain(stream),
}
#[cfg(not(feature = "rustls"))]
MaybeTls::Plain(stream)
} else {
MaybeTls::Plain(stream)
};
let request = read_request(&mut socket).await?;
if let Some(defect) = request.upgrade_defect() {
let (status, reason) = defect.status();
self.refuse(&mut socket, request.identity(), status, reason, remote)
.await;
return Ok(());
}
let identity = request.identity();
let peer_certificate = socket.peer_certificate();
let authorization = request.header("authorization");
let profile = match (&peer_certificate, socket_is_tls(&socket), authorization) {
(Some(_), _, _) => SecurityProfile::TlsClientCertificate,
(None, true, _) => SecurityProfile::TlsBasicAuth,
(None, false, Some(_)) => SecurityProfile::BasicAuth,
(None, false, None) => SecurityProfile::Unsecured,
};
let Some(identity) = identity else {
self.refuse(&mut socket, None, 400, "Bad Request", remote)
.await;
return Ok(());
};
let credentials = match peer_certificate {
Some(der) => Credentials::ClientCertificate { der },
None => authorization.map_or(Credentials::None, Credentials::from_authorization_header),
};
if let Credentials::Basic { user, .. } = &credentials {
if user != identity.as_str() {
#[cfg(feature = "tracing")]
tracing::warn!(
path_identity = %identity,
basic_user = %user,
%remote,
"the Basic username does not match the URL identity (A00.FR.204/207)"
);
self.refuse(&mut socket, Some(identity), 401, "Unauthorized", remote)
.await;
return Ok(());
}
}
let offered: Vec<Version> = request.subprotocols();
let auth = Auth {
identity: identity.clone(),
credentials,
remote,
profile,
path: request.path.clone(),
offered: offered.clone(),
};
let session = match self.authenticator.authenticate(auth).await {
AuthOutcome::Accept(session) => session,
AuthOutcome::Reject => {
self.refuse(&mut socket, Some(identity), 401, "Unauthorized", remote)
.await;
return Ok(());
}
AuthOutcome::Unknown => {
self.refuse(&mut socket, Some(identity), 404, "Not Found", remote)
.await;
return Ok(());
}
};
if self.router.sessions.lock().await.len() >= self.max_connections {
self.refuse(
&mut socket,
Some(identity),
503,
"Service Unavailable",
remote,
)
.await;
return Ok(());
}
let offer = Subprotocol::new(offered);
let selected = offer.select(self.versions.offered());
let key = request.websocket_key().unwrap_or_default().to_owned();
let Some(version) = selected else {
write_accept(&mut socket, &key, None, None).await?;
let mut ws = super::ws::attach(
socket,
WsCodec::new(WsRole::Server, self.ws_config),
&request.head.rest,
);
let _ = ws
.send(Message::Close(Some(CloseFrame::new(
CloseCode::PROTOCOL_ERROR,
"no common OCPP subprotocol",
))))
.await;
let _ = ws.close().await;
let _ = self.events.send(SessionEvent::Refused {
identity: Some(identity),
status: 101,
remote,
});
return Ok(());
};
#[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 socket,
&key,
Some(version.subprotocol()),
extensions.as_deref(),
)
.await?;
let ws = super::ws::attach(socket, codec, &request.head.rest);
self.run_session(ws, identity, version, remote, session)
.await;
Ok(())
}
async fn refuse(
&self,
socket: &mut MaybeTls,
identity: Option<Identity>,
status: u16,
reason: &str,
remote: SocketAddr,
) {
let _ = write_refusal(socket, status, reason).await;
let _ = tokio::io::AsyncWriteExt::shutdown(socket).await;
let _ = self.events.send(SessionEvent::Refused {
identity,
status,
remote,
});
}
async fn run_session(
self: &Arc<Self>,
socket: WebSocket<MaybeTls>,
identity: Identity,
version: Version,
remote: SocketAddr,
session: SessionContext,
) {
let (commands_tx, mut commands_rx) = mpsc::channel(64);
let (events_tx, session_events) = broadcast::channel(256);
lift_to_fleet(session_events, self.events.clone(), identity.clone());
let (state_tx, state_rx) = watch::channel(SessionState {
connected: false,
version,
boot: BootState::Idle,
queued: 0,
});
let shared = Arc::new(Shared {
identity: identity.clone(),
remote: Some(remote),
session,
decode: (self.decode)(&identity),
commands: commands_tx,
events: events_tx,
state: state_rx,
});
let handle = Handle::new(shared.clone());
let mut config = self
.engine
.clone()
.unwrap_or_else(|| EngineConfig::new(Role::Csms, version));
config.role = Role::Csms;
config.version = version;
if self.message_rate.is_some() {
config.inbound_rate = self.message_rate;
}
let Ok(engine) = Engine::with_store(config, MemStore::new()) else {
return;
};
let mut driver = Driver::new(engine, shared.clone(), self.handler.clone(), state_tx);
driver.idle_timeout = self.idle_timeout;
let session_id = self.router.next_session_id();
let superseded = {
let mut sessions = self.router.sessions.lock().await;
match sessions.remove(&identity) {
Some(previous) if self.supersede => {
let _ = self.events.send(SessionEvent::Superseded {
identity: identity.clone(),
});
Some(previous)
}
Some(previous) => {
sessions.insert(identity.clone(), previous);
return;
}
None => None,
}
};
if let Some(previous) = superseded {
let drain = self.supersede_drain;
tokio::spawn(async move {
let _ = tokio::time::timeout(drain, previous.handle.shutdown(drain)).await;
previous.task.abort();
});
}
let _ = self.events.send(SessionEvent::Opened {
identity: identity.clone(),
version,
remote,
compressed: socket.codec().is_compressed(),
});
let server = self.clone();
let session_identity = identity.clone();
let keepalive = self.keepalive;
let task = tokio::spawn(async move {
let reason = driver
.run(socket, &mut commands_rx, version, keepalive)
.await;
driver.abandon(&CallFailure::Disconnected);
{
let mut sessions = server.router.sessions.lock().await;
if sessions
.get(&session_identity)
.is_some_and(|session| session.id == session_id)
{
sessions.remove(&session_identity);
}
}
let _ = server.events.send(SessionEvent::Closed {
identity: session_identity,
reason,
});
});
self.router.sessions.lock().await.insert(
identity,
Session {
id: session_id,
handle,
task,
},
);
}
}
fn socket_is_tls(socket: &MaybeTls) -> bool {
!matches!(socket, MaybeTls::Plain(_))
}
#[derive(Clone)]
pub struct CsmsHandle {
router: Arc<Router>,
events: broadcast::Sender<SessionEvent>,
}
impl CsmsHandle {
pub async fn session(&self, identity: &Identity) -> Option<Handle> {
self.router
.sessions
.lock()
.await
.get(identity)
.map(|session| session.handle.clone())
}
pub async fn sessions(&self) -> Vec<Identity> {
self.router.sessions.lock().await.keys().cloned().collect()
}
pub async fn len(&self) -> usize {
self.router.sessions.lock().await.len()
}
pub async fn is_empty(&self) -> bool {
self.len().await == 0
}
pub async fn call<R: Request + Confirmed>(
&self,
identity: &Identity,
request: R,
) -> Result<R::Response, CallFailure> {
self.call_with(identity, request, CallOptions::default())
.await
}
pub async fn call_with<R: Request + Confirmed>(
&self,
identity: &Identity,
request: R,
options: CallOptions,
) -> Result<R::Response, CallFailure> {
match self.session(identity).await {
Some(handle) => handle.call_with(request, options).await,
None => Err(CallFailure::Disconnected),
}
}
pub async fn send<R>(&self, identity: &Identity, request: R) -> Result<(), CallFailure>
where
R: Request<Response = NoResponse> + Unconfirmed,
{
match self.session(identity).await {
Some(handle) => handle.send(request).await,
None => Err(CallFailure::Disconnected),
}
}
#[must_use]
pub fn events(&self) -> broadcast::Receiver<SessionEvent> {
self.events.subscribe()
}
pub async fn shutdown(&self, deadline: Duration) {
let handles: Vec<Handle> = self
.router
.sessions
.lock()
.await
.values()
.map(|session| session.handle.clone())
.collect();
let drains = handles
.into_iter()
.map(|handle| async move { handle.shutdown(deadline).await });
futures_util::future::join_all(drains).await;
}
}
fn lift_to_fleet(
mut session_events: broadcast::Receiver<super::Event>,
fleet: broadcast::Sender<SessionEvent>,
identity: Identity,
) {
tokio::spawn(async move {
loop {
let event = match session_events.recv().await {
Ok(event) => event,
Err(broadcast::error::RecvError::Lagged(_)) => continue,
Err(broadcast::error::RecvError::Closed) => break,
};
let lifted = match event {
super::Event::Violation(violation) => SessionEvent::Violation {
identity: identity.clone(),
violation,
},
super::Event::Repaired {
action,
id,
repairs,
} => SessionEvent::Repaired {
identity: identity.clone(),
action,
id,
repairs,
},
super::Event::RateLimited => SessionEvent::RateLimited {
identity: identity.clone(),
},
_ => continue,
};
let _ = fleet.send(lifted);
}
});
}