use std::collections::{HashMap, HashSet};
use std::ops::RangeInclusive;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tokio::net::TcpListener;
use tokio::task::AbortHandle;
use krot_proto::{PubKey, SessionId, TunnelId};
use crate::error::ServerError;
use crate::rate::RateLimitState;
#[derive(Debug)]
pub struct TunnelInfo {
pub id: TunnelId,
pub owner: PubKey,
pub session_id: SessionId,
pub kind: RegisteredKind,
pub state: TunnelState,
pub tcp_listener: Option<Arc<TcpListener>>,
pub rate: Arc<RateLimitState>,
pub inspect: bool,
}
#[derive(Debug)]
pub enum RegisteredKind {
Tcp { public_port: u16 },
Http { label: String },
}
#[derive(Debug)]
pub enum TunnelState {
Live {
connection: krot_transport::Connection,
abort: Option<AbortHandle>,
},
Dangling {
expires_at: Instant,
},
}
#[derive(Debug)]
pub struct TunnelRegistry {
port_pool: RangeInclusive<u16>,
state: Mutex<State>,
}
#[derive(Debug)]
struct State {
next_id: u64,
used_ports: HashSet<u16>,
used_labels: HashSet<String>,
tunnels: HashMap<TunnelId, TunnelInfo>,
labels: HashMap<String, TunnelId>,
}
#[derive(Debug, Clone)]
pub struct TunnelSnapshot {
pub tunnel_id: TunnelId,
pub owner: PubKey,
pub session_id: SessionId,
pub inspect: bool,
pub kind: TunnelSnapshotKind,
pub live: bool,
}
#[derive(Debug, Clone)]
pub enum TunnelSnapshotKind {
Http { label: String },
Tcp { public_port: u16 },
}
#[derive(Debug, Clone)]
pub struct ResolvedTunnel {
pub id: TunnelId,
pub connection: krot_transport::Connection,
pub rate: Arc<RateLimitState>,
pub inspect: bool,
}
#[derive(Debug)]
pub enum ResumeOutcome {
Reattached {
tunnel_id: TunnelId,
info: ResumedInfo,
inspect: bool,
},
Unknown,
IdentityMismatch,
}
#[derive(Debug)]
pub enum ResumedInfo {
Http {
label: String,
},
Tcp {
public_port: u16,
listener: Arc<TcpListener>,
},
}
impl TunnelRegistry {
#[must_use]
pub fn new(port_pool: RangeInclusive<u16>) -> Self {
Self {
port_pool,
state: Mutex::new(State {
next_id: 1,
used_ports: HashSet::new(),
used_labels: HashSet::new(),
tunnels: HashMap::new(),
labels: HashMap::new(),
}),
}
}
pub fn allocate_tcp(&self, allowlist: Option<&[u16]>) -> Result<(TunnelId, u16), ServerError> {
let mut state = self.state.lock().unwrap();
let port = pick_free_port(&self.port_pool, &state.used_ports, allowlist)
.ok_or(ServerError::PortPoolExhausted)?;
state.used_ports.insert(port);
let id = fresh_id(&mut state);
Ok((id, port))
}
pub fn allocate_http(&self, label: &str) -> Result<TunnelId, ServerError> {
let mut state = self.state.lock().unwrap();
if state.used_labels.contains(label) {
return Err(ServerError::Keys(format!("label taken: {label}")));
}
state.used_labels.insert(label.to_string());
Ok(fresh_id(&mut state))
}
pub fn insert(&self, info: TunnelInfo) {
let mut state = self.state.lock().unwrap();
if let RegisteredKind::Http { label } = &info.kind {
state.labels.insert(label.clone(), info.id);
}
state.tunnels.insert(info.id, info);
}
pub fn resolve_label(&self, label: &str) -> Option<ResolvedTunnel> {
let state = self.state.lock().unwrap();
let id = state.labels.get(label).copied()?;
let info = state.tunnels.get(&id)?;
match &info.state {
TunnelState::Live { connection, .. } => Some(ResolvedTunnel {
id,
connection: connection.clone(),
rate: Arc::clone(&info.rate),
inspect: info.inspect,
}),
TunnelState::Dangling { .. } => None,
}
}
pub fn remove(&self, id: TunnelId) {
let mut state = self.state.lock().unwrap();
remove_locked(&mut state, id);
}
pub fn remove_all_owned_by(&self, owner: &PubKey) {
let mut state = self.state.lock().unwrap();
let ids: Vec<TunnelId> = state
.tunnels
.iter()
.filter_map(|(id, info)| (info.owner == *owner).then_some(*id))
.collect();
for id in ids {
remove_locked(&mut state, id);
}
}
pub fn mark_dangling(&self, owner: &PubKey, grace: Duration) {
let mut state = self.state.lock().unwrap();
let expires_at = Instant::now() + grace;
let ids: Vec<TunnelId> = state
.tunnels
.iter()
.filter_map(|(id, info)| (info.owner == *owner).then_some(*id))
.collect();
for id in ids {
let Some(info) = state.tunnels.get_mut(&id) else {
continue;
};
if matches!(info.state, TunnelState::Dangling { .. }) {
continue;
}
let old = std::mem::replace(&mut info.state, TunnelState::Dangling { expires_at });
if let TunnelState::Live { abort: Some(a), .. } = old {
a.abort();
}
}
}
pub fn reap_expired(&self) -> usize {
let mut state = self.state.lock().unwrap();
let now = Instant::now();
let ids: Vec<TunnelId> = state
.tunnels
.iter()
.filter_map(|(id, info)| match &info.state {
TunnelState::Dangling { expires_at } if *expires_at <= now => Some(*id),
_ => None,
})
.collect();
let n = ids.len();
for id in ids {
remove_locked(&mut state, id);
}
n
}
pub fn try_resume(
&self,
label: &str,
session_id: SessionId,
pubkey: &PubKey,
connection: krot_transport::Connection,
) -> ResumeOutcome {
let mut state = self.state.lock().unwrap();
let mut candidate = state.labels.get(label).copied();
if candidate.is_none() {
candidate = state.tunnels.iter().find_map(|(id, info)| {
if info.session_id != session_id {
return None;
}
if !matches!(info.state, TunnelState::Dangling { .. }) {
return None;
}
if !matches!(info.kind, RegisteredKind::Tcp { .. }) {
return None;
}
Some(*id)
});
}
let Some(id) = candidate else {
return ResumeOutcome::Unknown;
};
let Some(info) = state.tunnels.get(&id) else {
return ResumeOutcome::Unknown;
};
if !matches!(info.state, TunnelState::Dangling { .. }) {
return ResumeOutcome::Unknown;
}
if info.session_id != session_id {
return ResumeOutcome::Unknown;
}
if info.owner != *pubkey {
return ResumeOutcome::IdentityMismatch;
}
let info = state.tunnels.get_mut(&id).unwrap();
info.state = TunnelState::Live {
connection,
abort: None,
};
let resumed = match &info.kind {
RegisteredKind::Http { label } => ResumedInfo::Http {
label: label.clone(),
},
RegisteredKind::Tcp { public_port } => {
let Some(listener) = info.tcp_listener.clone() else {
return ResumeOutcome::Unknown;
};
ResumedInfo::Tcp {
public_port: *public_port,
listener,
}
}
};
ResumeOutcome::Reattached {
tunnel_id: id,
info: resumed,
inspect: info.inspect,
}
}
pub fn set_tcp_abort(&self, id: TunnelId, new_abort: AbortHandle) {
let mut state = self.state.lock().unwrap();
if let Some(info) = state.tunnels.get_mut(&id) {
if let TunnelState::Live { abort, .. } = &mut info.state {
*abort = Some(new_abort);
}
}
}
pub fn snapshot(&self) -> Vec<TunnelSnapshot> {
let state = self.state.lock().unwrap();
state
.tunnels
.values()
.map(|info| TunnelSnapshot {
tunnel_id: info.id,
owner: info.owner,
session_id: info.session_id,
inspect: info.inspect,
kind: match &info.kind {
RegisteredKind::Http { label } => TunnelSnapshotKind::Http {
label: label.clone(),
},
RegisteredKind::Tcp { public_port } => TunnelSnapshotKind::Tcp {
public_port: *public_port,
},
},
live: matches!(info.state, TunnelState::Live { .. }),
})
.collect()
}
pub fn len(&self) -> usize {
self.state.lock().unwrap().tunnels.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn count_owned_by(&self, owner: &PubKey) -> usize {
self.state
.lock()
.unwrap()
.tunnels
.values()
.filter(|t| t.owner == *owner)
.count()
}
}
fn remove_locked(state: &mut State, id: TunnelId) {
let Some(info) = state.tunnels.remove(&id) else {
return;
};
match info.kind {
RegisteredKind::Tcp { public_port } => {
state.used_ports.remove(&public_port);
}
RegisteredKind::Http { label } => {
state.used_labels.remove(&label);
state.labels.remove(&label);
}
}
if let TunnelState::Live { abort: Some(a), .. } = info.state {
a.abort();
}
}
fn fresh_id(state: &mut State) -> TunnelId {
let id = TunnelId(state.next_id);
state.next_id = state.next_id.checked_add(1).unwrap_or(1);
id
}
fn pick_free_port(
pool: &RangeInclusive<u16>,
used: &HashSet<u16>,
allowlist: Option<&[u16]>,
) -> Option<u16> {
pool.clone().find(|p| {
if used.contains(p) {
return false;
}
match allowlist {
Some(list) => list.contains(p),
None => true,
}
})
}
#[must_use]
pub fn is_valid_label(label: &str) -> bool {
if label == "admin" {
return false;
}
let len = label.len();
if !(1..=63).contains(&len) {
return false;
}
let bytes = label.as_bytes();
let is_alnum = |b: u8| b.is_ascii_lowercase() || b.is_ascii_digit();
if !is_alnum(bytes[0]) || !is_alnum(bytes[len - 1]) {
return false;
}
if len < 3 {
return true;
}
bytes[1..len - 1].iter().all(|&b| is_alnum(b) || b == b'-')
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn label_grammar() {
assert!(is_valid_label("alice"));
assert!(is_valid_label("a"));
assert!(is_valid_label("a1-b2"));
assert!(is_valid_label(&"a".repeat(63)));
assert!(!is_valid_label(""));
assert!(!is_valid_label("Alice"));
assert!(!is_valid_label("-alice"));
assert!(!is_valid_label("alice-"));
assert!(!is_valid_label("al ice"));
assert!(!is_valid_label("admin"));
assert!(!is_valid_label(&"a".repeat(64)));
}
}