use super::{
ConnectionLimiter, ConnectionSlot,
connection::{self, report_connection_result},
library::LibraryHandle,
socket::{apply_handshake_timeout, tune_accepted_socket},
tls::{Transport, accept_tls},
};
use indicatrix_net::messages::PeerRole;
use std::{
collections::{HashMap, hash_map::Entry},
io::{Read, Write},
net::{IpAddr, Ipv4Addr, SocketAddr, TcpListener, TcpStream},
path::PathBuf,
sync::{Arc, Mutex, PoisonError},
thread,
};
#[derive(Debug, Clone)]
pub struct PreAuthAddresses {
held: Arc<Mutex<HashMap<IpAddr, usize>>>,
max: usize,
}
#[derive(Debug)]
pub struct AddressSlot {
held: Arc<Mutex<HashMap<IpAddr, usize>>>,
address: IpAddr,
}
impl PreAuthAddresses {
#[must_use]
pub fn new(max: usize) -> Self {
Self {
held: Arc::new(Mutex::new(HashMap::new())),
max,
}
}
pub fn try_admit(&self, peer: Option<SocketAddr>) -> Result<AddressSlot, usize> {
let address = peer.map_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED), |p| p.ip().to_canonical());
let mut held = self.held.lock().unwrap_or_else(PoisonError::into_inner);
let count = held.get(&address).copied().unwrap_or(0);
if count >= self.max {
return Err(count);
}
held.insert(address, count + 1);
drop(held);
Ok(AddressSlot {
held: Arc::clone(&self.held),
address,
})
}
}
impl Drop for AddressSlot {
fn drop(&mut self) {
let mut held = self.held.lock().unwrap_or_else(PoisonError::into_inner);
if let Entry::Occupied(mut entry) = held.entry(self.address) {
if *entry.get() <= 1 {
entry.remove();
} else {
*entry.get_mut() -= 1;
}
}
}
}
struct PreAuthSlots {
_address: AddressSlot,
_handshake: ConnectionSlot,
}
pub struct ViewerListener {
pub transport: Transport,
pub limiter: ConnectionLimiter,
pub handshake_limiter: ConnectionLimiter,
pub pre_auth_addresses: PreAuthAddresses,
pub db_path: PathBuf,
pub max_connections: usize,
#[cfg(feature = "worker")]
pub render: RenderSetup,
}
#[cfg(feature = "worker")]
pub struct RenderSetup {
pub threads: usize,
pub gpu: Arc<indicatrix::renderer::gpu_backend::GpuBackend>,
pub compute_mode: crate::cli::ComputeMode,
pub own_lane: bool,
pub registry: Option<Arc<crate::coordinator::Registry>>,
pub coordinator: Arc<crate::coordinator::Coordinator>,
pub assets: Option<Arc<crate::assets::AssetCache>>,
pub payload: indicatrix_net::messages::adaptive::PayloadChoice,
}
type PeerAuth = (
Option<PeerRole>,
Option<rustls::pki_types::CertificateDer<'static>>,
);
#[cfg(feature = "worker")]
fn viewer_key(
certificate: Option<&rustls::pki_types::CertificateDer<'_>>,
peer: Option<SocketAddr>,
) -> String {
certificate.map_or_else(
|| {
format!(
"address:{}",
peer.map_or_else(|| "unknown".to_string(), |p| p.ip().to_string())
)
},
|cert| {
format!(
"certificate:{}",
indicatrix_net::tls::fingerprint_to_hex(&indicatrix_net::tls::fingerprint(cert))
)
},
)
}
pub fn run_accept_loop(listener: &TcpListener, shared: &Arc<ViewerListener>) {
for incoming in listener.incoming() {
match incoming {
Ok(stream) => {
let peer = stream.peer_addr().ok();
tune_accepted_socket(&stream, peer);
apply_handshake_timeout(&stream, peer);
let address_slot = match shared.pre_auth_addresses.try_admit(peer) {
Ok(slot) => slot,
Err(held) => {
tracing::warn!(
"connection {peer:?}: refusing -- this address already has {held} connection(s) \
that have not finished authenticating (--max-preauth-per-ip)"
);
continue;
}
};
let Ok(handshake_slot) = shared.handshake_limiter.try_acquire() else {
tracing::warn!(
"connection {peer:?}: refusing -- too many not-yet-authenticated connections in \
flight (see --max-connections)"
);
continue;
};
let pre_auth = PreAuthSlots {
_address: address_slot,
_handshake: handshake_slot,
};
let pre_acquired_slot = matches!(shared.transport, Transport::Insecure)
.then(|| shared.limiter.try_acquire());
spawn_connection_handler(stream, peer, pre_auth, pre_acquired_slot, shared);
}
Err(e) => tracing::warn!("accept error: {e}"),
}
}
}
fn spawn_connection_handler(
stream: TcpStream,
peer: Option<SocketAddr>,
pre_auth: PreAuthSlots,
pre_acquired_slot: Option<Result<ConnectionSlot, usize>>,
shared_ref: &Arc<ViewerListener>,
) {
let shared = Arc::clone(shared_ref);
match &shared_ref.transport {
Transport::Insecure => {
tracing::warn!(
"--insecure-no-tls: accepted PLAINTEXT connection from {peer:?} -- no TLS, no \
authentication"
);
let slot = pre_acquired_slot.expect(
"the accept loop always pre-acquires the real slot for Transport::Insecure",
);
thread::spawn(move || {
let mut stream = stream;
match slot {
Ok(_slot) => {
drop(pre_auth);
serve_accepted(stream, peer, (None, None), &shared);
}
Err(active) => {
connection::refuse_for_capacity(
&mut stream,
peer,
active,
shared.max_connections,
);
drop(pre_auth);
}
}
});
}
Transport::Tls { config, auth } => {
let config = Arc::clone(config);
let auth = auth.clone();
thread::spawn(move || {
let Some((mut tls_stream, cert_role)) = accept_tls(stream, &config, &auth, peer)
else {
return; };
let certificate = tls_stream
.conn
.peer_certificates()
.and_then(<[_]>::first)
.map(|c| c.clone().into_owned());
match shared.limiter.try_acquire() {
Ok(_slot) => {
drop(pre_auth);
serve_accepted(tls_stream, peer, (Some(cert_role), certificate), &shared);
}
Err(active) => connection::refuse_for_capacity(
&mut tls_stream,
peer,
active,
shared.max_connections,
),
}
});
}
}
}
#[cfg(feature = "worker")]
fn serve_accepted<S>(
stream: S,
peer: Option<SocketAddr>,
(cert_role, certificate): PeerAuth,
shared: &ViewerListener,
) where
S: Read + Write + crate::stream_emit::TimeoutRead + crate::stream_emit::TimeoutWrite,
{
let library = LibraryHandle::lazy(shared.db_path.clone(), peer);
let render = &shared.render;
let viewer = viewer_key(certificate.as_ref(), peer);
let preference = super::socket::payload_preference_for_choice(render.payload, peer);
let ctx = connection::ViewerContext {
threads: render.threads,
gpu: &render.gpu,
db: &library,
compute_mode: render.compute_mode,
encodings: &preference,
link: Some(connection::LinkSettings {
choice: render.payload,
peer: viewer.clone(),
loopback: connection::is_loopback_peer(peer),
}),
own_lane: render.own_lane,
registry: render.registry.as_ref(),
cert_role,
coordinator: Some((&render.coordinator, viewer)),
assets: render.assets.as_deref(),
};
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
connection::handle_viewer_connection(stream, &ctx)
}));
report_connection_result(peer, result);
}
#[cfg(not(feature = "worker"))]
fn serve_accepted<S: Read + Write + connection::ClearHandshakeTimeout>(
stream: S,
peer: Option<SocketAddr>,
(cert_role, _certificate): PeerAuth,
shared: &ViewerListener,
) {
let library = LibraryHandle::lazy(shared.db_path.clone(), peer);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
connection::handle_connection(stream, &library, cert_role)
}));
report_connection_result(peer, result);
}
#[cfg(test)]
mod tests {
use super::PreAuthAddresses;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
fn peer(last: u8) -> SocketAddr {
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(10, 0, 0, last)), 40_000)
}
#[test]
fn admits_up_to_the_cap_refuses_the_next_and_a_release_frees_one() {
let counter = PreAuthAddresses::new(2);
let first = counter
.try_admit(Some(peer(1)))
.expect("1st is under the cap");
let _second = counter
.try_admit(Some(peer(1)))
.expect("2nd is exactly at the cap");
assert_eq!(
counter
.try_admit(Some(peer(1)))
.expect_err("3rd is over the cap"),
2,
"the refusal reports how many the address already holds"
);
drop(first);
let _third = counter
.try_admit(Some(peer(1)))
.expect("a slot freed by drop can be taken again");
counter
.try_admit(Some(peer(1)))
.expect_err("back at the cap after the re-admission");
}
#[test]
fn addresses_are_counted_independently_and_the_map_empties_again() {
let counter = PreAuthAddresses::new(1);
let a = counter.try_admit(Some(peer(1))).unwrap();
let b = counter
.try_admit(Some(peer(2)))
.expect("another address has its own count");
counter.try_admit(Some(peer(1))).unwrap_err();
drop((a, b));
assert!(counter.held.lock().unwrap().is_empty());
}
#[test]
fn an_ipv4_mapped_ipv6_peer_counts_as_its_ipv4_address() {
let counter = PreAuthAddresses::new(1);
let _v4 = counter.try_admit(Some(peer(7))).unwrap();
let mapped = Ipv4Addr::new(10, 0, 0, 7).to_ipv6_mapped();
let via_v6 = Some(SocketAddr::new(IpAddr::V6(mapped), 40_001));
counter
.try_admit(via_v6)
.expect_err("the mapped form is the same address");
let other = Some(SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 40_002));
counter
.try_admit(other)
.expect("a different address is admitted");
}
#[test]
fn a_refused_attempt_counts_for_nothing() {
let counter = PreAuthAddresses::new(1);
let held = counter.try_admit(Some(peer(3))).unwrap();
for _ in 0..5 {
counter.try_admit(Some(peer(3))).unwrap_err();
}
drop(held);
counter
.try_admit(Some(peer(3)))
.expect("refusals never leaked a count");
}
}