use std::net::SocketAddr;
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
use tokio::io::AsyncWriteExt;
use tokio::net::{TcpListener, TcpStream};
use tracing::{debug, warn};
use krot_proto::consts::DATA_FIRST_BYTE_DEADLINE;
use krot_proto::{DataHeader, InspectionPrelude, StreamKind, TunnelId};
use krot_transport::{write_frame, BidiStream};
use crate::rate::{run_metered, RateLimitState};
pub async fn run_tcp_tunnel(
listener: Arc<TcpListener>,
connection: krot_transport::Connection,
tunnel_id: TunnelId,
rate: Arc<RateLimitState>,
inspect: bool,
) {
loop {
tokio::select! {
accept = listener.accept() => {
match accept {
Ok((tcp, peer)) => {
let conn = connection.clone();
let rate = Arc::clone(&rate);
tokio::spawn(async move {
if let Err(e) = handle_incoming(tcp, peer, conn, tunnel_id, rate, inspect).await {
debug!(?peer, ?tunnel_id, "tunnel connection ended: {e}");
}
});
}
Err(e) => {
warn!(?tunnel_id, "listener accept failed: {e}");
return;
}
}
}
() = connection.closed() => {
debug!(?tunnel_id, "quic connection closed, stopping tunnel");
return;
}
}
}
}
async fn handle_incoming(
tcp: TcpStream,
peer: SocketAddr,
connection: krot_transport::Connection,
tunnel_id: TunnelId,
rate: Arc<RateLimitState>,
inspect: bool,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
debug!(?peer, ?tunnel_id, "accepted public TCP, opening QUIC bi");
let (mut send, recv) = connection.open_bi().await?;
let header = DataHeader {
kind: StreamKind::DataTcp,
tunnel_id,
};
send.write_all(&header.to_bytes()).await?;
if inspect {
let prelude = InspectionPrelude {
accept_unix_secs: unix_secs_now(),
peer: peer.to_string(),
http: None,
};
write_frame(&mut send, &prelude).await?;
}
let bidi = BidiStream::new(send, recv);
let _ = run_metered(tcp, bidi, &rate, tunnel_id, DATA_FIRST_BYTE_DEADLINE).await?;
Ok(())
}
fn unix_secs_now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_or(0, |d| d.as_secs())
}