use alloc::string::String;
use alloc::sync::Arc;
use alloc::vec::Vec;
use crate::connect::proto::{
AccessToken, COMMUNICATION_TOKEN_LIFETIME, CommunicationDetails, CommunicationToken,
ConnectError, NodeId, SessionGrant, SessionInitServer, SessionRequest, TokenStore,
UnpairRequest,
};
use super::store::Store;
use crate::types::{ProtocolVersion, Timestamp};
pub struct SessionService {
store: Arc<dyn Store>,
websocket_url: String,
s2_message_versions: Vec<ProtocolVersion>,
issued: std::sync::Mutex<Vec<IssuedConnection>>,
}
#[derive(Debug)]
struct IssuedConnection {
remote: NodeId,
token: CommunicationToken,
issued: Timestamp,
}
impl core::fmt::Debug for SessionService {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("SessionService")
.field("websocket_url", &self.websocket_url)
.field("s2_message_versions", &self.s2_message_versions)
.finish_non_exhaustive()
}
}
impl SessionService {
#[must_use]
pub fn new(store: Arc<dyn Store>, websocket_url: impl Into<String>) -> Self {
Self {
store,
websocket_url: websocket_url.into(),
s2_message_versions: alloc::vec![
crate::types::WireProfile::V1_0_0.connect_version(),
crate::types::WireProfile::V0_0_2Beta.connect_version(),
],
issued: std::sync::Mutex::new(Vec::new()),
}
}
#[must_use]
pub fn with_s2_message_versions(mut self, versions: Vec<ProtocolVersion>) -> Self {
self.s2_message_versions = versions;
self
}
#[must_use]
pub fn store(&self) -> &Arc<dyn Store> {
&self.store
}
fn machine(&self, remote: NodeId) -> Option<(NodeId, SessionInitServer)> {
let paired = self.store.paired(remote)?;
Some((
paired.local,
SessionInitServer::new(paired.local, remote, paired.tokens, &self.websocket_url)
.with_s2_message_versions(self.s2_message_versions.clone()),
))
}
pub fn initiate_session(
&self,
bearer: &AccessToken,
request: &SessionRequest,
access_entropy: &[u8],
now: Timestamp,
) -> Result<SessionGrant, ConnectError> {
let (local, mut machine) = self
.machine(request.client_node_id)
.ok_or(ConnectError::NotPaired)?;
let mut grant = machine.initiate_session(bearer, request, access_entropy, now)?;
self.store
.set_tokens(request.client_node_id, machine.tokens().clone());
grant.server_node_description = self.store.node(local);
Ok(grant)
}
pub fn confirm_access_token(
&self,
bearer: &AccessToken,
communication_entropy: &[u8],
now: Timestamp,
) -> Result<(NodeId, CommunicationDetails), ConnectError> {
let remote = self
.store
.node_for_token(bearer)
.ok_or(ConnectError::NotPaired)?;
let (_, mut machine) = self.machine(remote).ok_or(ConnectError::NotPaired)?;
let details = machine.confirm_access_token(bearer, communication_entropy, now)?;
self.store.set_tokens(remote, machine.tokens().clone());
let CommunicationDetails::WebSocket {
websocket_token, ..
} = &details;
if let Ok(mut issued) = self.issued.lock() {
issued.retain(|entry| {
now.saturating_duration_since(entry.issued) < COMMUNICATION_TOKEN_LIFETIME
&& entry.remote != remote
});
issued.push(IssuedConnection {
remote,
token: websocket_token.clone(),
issued: now,
});
}
Ok((remote, details))
}
pub fn authorize_connection(&self, presented: &str, now: Timestamp) -> Option<NodeId> {
let mut issued = self.issued.lock().ok()?;
issued.retain(|entry| {
now.saturating_duration_since(entry.issued) < COMMUNICATION_TOKEN_LIFETIME
});
let mut found = None;
for (index, entry) in issued.iter().enumerate() {
if entry.token.verify_str(presented) {
found = Some((index, entry.remote));
}
}
let (index, remote) = found?;
issued.remove(index);
Some(remote)
}
#[must_use]
pub fn pending_connections(&self) -> usize {
self.issued.lock().map_or(0, |issued| issued.len())
}
pub fn unpair(
&self,
bearer: &AccessToken,
request: &UnpairRequest,
) -> Result<(), ConnectError> {
let (_, mut machine) = self
.machine(request.client_node_id)
.ok_or(ConnectError::NotPaired)?;
machine.unpair(bearer, request)?;
self.store.unpair(request.client_node_id);
if let Ok(mut issued) = self.issued.lock() {
issued.retain(|entry| entry.remote != request.client_node_id);
}
Ok(())
}
#[must_use]
pub fn tokens(&self, remote: NodeId) -> Option<TokenStore> {
self.store.paired(remote).map(|p| p.tokens)
}
}