use std::net::SocketAddr;
use std::sync::Arc;
use tokio::sync::mpsc;
use tracing::{info, warn};
use krot_proto::consts::REGISTRATION_DEADLINE;
use krot_proto::{ClientFrame, ServerFrame, SessionId, TunnelId, TunnelKind};
use krot_transport::{read_frame, write_frame};
use crate::error::ClientError;
use crate::inspector::Inspector;
use crate::local_auth::AuthConfig;
use crate::proxy::handle_bi_inspected;
use crate::session::AuthenticatedSession;
#[derive(Debug, Clone)]
pub struct PublishedTunnel {
pub tunnel_id: TunnelId,
pub public_url: String,
pub public_port: Option<u16>,
}
pub type TunnelHandle = (
PublishedTunnel,
tokio::task::JoinHandle<Result<(), ClientError>>,
mpsc::Sender<()>,
);
pub async fn publish_tcp(
session: AuthenticatedSession,
label: &str,
local_target: SocketAddr,
) -> Result<TunnelHandle, ClientError> {
publish(
session,
label,
TunnelKind::Tcp { remote_port: None },
local_target,
None,
None,
None,
)
.await
}
pub async fn publish_tcp_resume(
session: AuthenticatedSession,
label: &str,
local_target: SocketAddr,
resume_session_id: SessionId,
) -> Result<TunnelHandle, ClientError> {
publish(
session,
label,
TunnelKind::Tcp { remote_port: None },
local_target,
None,
Some(resume_session_id),
None,
)
.await
}
pub async fn publish_http(
session: AuthenticatedSession,
label: &str,
local_target: SocketAddr,
inspector: Option<Arc<Inspector>>,
) -> Result<TunnelHandle, ClientError> {
publish(
session,
label,
TunnelKind::Http,
local_target,
inspector,
None,
None,
)
.await
}
pub async fn publish_http_authed(
session: AuthenticatedSession,
label: &str,
local_target: SocketAddr,
inspector: Option<Arc<Inspector>>,
auth: AuthConfig,
) -> Result<TunnelHandle, ClientError> {
publish(
session,
label,
TunnelKind::Http,
local_target,
inspector,
None,
Some(auth),
)
.await
}
pub async fn publish_http_resume(
session: AuthenticatedSession,
label: &str,
local_target: SocketAddr,
inspector: Option<Arc<Inspector>>,
resume_session_id: SessionId,
) -> Result<TunnelHandle, ClientError> {
publish(
session,
label,
TunnelKind::Http,
local_target,
inspector,
Some(resume_session_id),
None,
)
.await
}
async fn publish(
mut session: AuthenticatedSession,
label: &str,
kind: TunnelKind,
local_target: SocketAddr,
inspector: Option<Arc<Inspector>>,
resume_session_id: Option<SessionId>,
auth: Option<AuthConfig>,
) -> Result<TunnelHandle, ClientError> {
let inspect = inspector.is_some();
write_frame(
&mut session.send,
&ClientFrame::RegisterTunnel {
label: label.to_string(),
kind,
resume_session_id,
inspect,
},
)
.await?;
let reply = tokio::time::timeout(
REGISTRATION_DEADLINE,
read_frame::<ServerFrame>(&mut session.recv),
)
.await
.map_err(|_| ClientError::RegistrationTimeout)??;
let published = match reply {
ServerFrame::TunnelRegistered {
tunnel_id,
public_url,
public_port,
} => PublishedTunnel {
tunnel_id,
public_url,
public_port,
},
ServerFrame::TunnelRejected { code, detail } => {
return Err(ClientError::TunnelRejected(code, detail));
}
_ => return Err(ClientError::Protocol("expected TunnelRegistered")),
};
info!(url = %published.public_url, "tunnel published");
let (shutdown_tx, mut shutdown_rx) = mpsc::channel::<()>(1);
let tunnel_id = published.tunnel_id;
let connection = session.connection.clone();
let handle = tokio::spawn(async move {
let keep_control = session;
loop {
tokio::select! {
_ = shutdown_rx.recv() => {
keep_control.shutdown().await;
return Ok(());
}
accept = connection.accept_bi() => {
match accept {
Ok((send, recv)) => {
let target = local_target;
let insp = inspector.clone();
let auth = auth.clone();
tokio::spawn(async move {
if let Err(e) = handle_bi_inspected(send, recv, tunnel_id, target, insp, inspect, auth).await {
warn!("proxy stream ended with error: {e}");
}
});
}
Err(e) => {
info!("quic connection ended: {e}");
return Ok(());
}
}
}
}
}
});
Ok((published, handle, shutdown_tx))
}