add connection info to router

Signed-off-by: Jason Volk <jason@zemos.net>

src/router/layers.rs

@@ -25,7 +25,7 @@ const CONDUWUIT_CSP: &str = "sandbox; default-src 'none'; font-src 'none'; scrip
                              form-action 'none'; base-uri 'none';";
 const CONDUWUIT_PERMISSIONS_POLICY: &str = "interest-cohort=(),browsing-topics=()";
 
-pub(crate) fn build(server: &Arc<Server>) -> io::Result<axum::routing::IntoMakeService<Router>> {
+pub(crate) fn build(server: &Arc<Server>) -> io::Result<Router> {
 	let layers = ServiceBuilder::new();
 
 	#[cfg(feature = "sentry_telemetry")]
@@ -74,10 +74,7 @@ pub(crate) fn build(server: &Arc<Server>) -> io::Result<axum::routing::IntoMakeS
 		.layer(body_limit_layer(server))
 		.layer(CatchPanicLayer::custom(catch_panic));
 
-	let routes = router::build(server);
+	Ok(router::build(server).layer(layers))
-	let layers = routes.layer(layers);
-
-	Ok(layers.into_make_service())
 }
 
 #[cfg(any(feature = "zstd_compression", feature = "gzip_compression", feature = "brotli_compression"))]

src/router/serve/mod.rs

@@ -4,14 +4,14 @@ mod unix;
 
 use std::sync::Arc;
 
-use axum::{routing::IntoMakeService, Router};
+use axum::Router;
 use axum_server::Handle as ServerHandle;
 use conduit::{Error, Result, Server};
 use tokio::sync::broadcast;
 
 /// Serve clients
 pub(super) async fn serve(
-	server: &Arc<Server>, app: IntoMakeService<Router>, handle: ServerHandle, shutdown: broadcast::Receiver<()>,
+	server: &Arc<Server>, app: Router, handle: ServerHandle, shutdown: broadcast::Receiver<()>,
 ) -> Result<(), Error> {
 	let config = &server.config;
 	let addrs = config.get_bind_addrs();

src/router/serve/plain.rs

@@ -3,15 +3,16 @@ use std::{
 	sync::{atomic::Ordering, Arc},
 };
 
-use axum::{routing::IntoMakeService, Router};
+use axum::Router;
 use axum_server::{bind, Handle as ServerHandle};
 use conduit::{debug_info, Result, Server};
 use tokio::task::JoinSet;
 use tracing::info;
 
 pub(super) async fn serve(
-	server: &Arc<Server>, app: IntoMakeService<Router>, handle: ServerHandle, addrs: Vec<SocketAddr>,
+	server: &Arc<Server>, app: Router, handle: ServerHandle, addrs: Vec<SocketAddr>,
 ) -> Result<()> {
+	let app = app.into_make_service_with_connect_info::<SocketAddr>();
 	let mut join_set = JoinSet::new();
 	for addr in &addrs {
 		join_set.spawn_on(bind(*addr).handle(handle.clone()).serve(app.clone()), server.runtime());

src/router/serve/tls.rs

@@ -1,6 +1,6 @@
 use std::{net::SocketAddr, sync::Arc};
 
-use axum::{routing::IntoMakeService, Router};
+use axum::Router;
 use axum_server::{bind_rustls, tls_rustls::RustlsConfig, Handle as ServerHandle};
 #[cfg(feature = "axum_dual_protocol")]
 use axum_server_dual_protocol::ServerExt;
@@ -9,7 +9,7 @@ use tokio::task::JoinSet;
 use tracing::{debug, info, warn};
 
 pub(super) async fn serve(
-	server: &Arc<Server>, app: IntoMakeService<Router>, handle: ServerHandle, addrs: Vec<SocketAddr>,
+	server: &Arc<Server>, app: Router, handle: ServerHandle, addrs: Vec<SocketAddr>,
 ) -> Result<()> {
 	let config = &server.config;
 	let tls = config.tls.as_ref().expect("TLS configuration");
@@ -31,6 +31,7 @@ pub(super) async fn serve(
 	}
 
 	let mut join_set = JoinSet::new();
+	let app = app.into_make_service_with_connect_info::<SocketAddr>();
 	if cfg!(feature = "axum_dual_protocol") && tls.dual_protocol {
 		#[cfg(feature = "axum_dual_protocol")]
 		for addr in &addrs {

src/router/serve/unix.rs

@@ -1,8 +1,15 @@
 #![cfg(unix)]
 
-use std::{path::Path, sync::Arc};
+use std::{
+	net::{self, IpAddr, Ipv4Addr},
+	path::Path,
+	sync::Arc,
+};
 
-use axum::{extract::Request, routing::IntoMakeService, Router};
+use axum::{
+	extract::{connect_info::IntoMakeServiceWithConnectInfo, Request},
+	Router,
+};
 use conduit::{debug_error, trace, utils, Error, Result, Server};
 use hyper::{body::Incoming, service::service_fn};
 use hyper_util::{
@@ -19,12 +26,15 @@ use tower::{Service, ServiceExt};
 use tracing::{debug, info, warn};
 use utils::unwrap_infallible;
 
+type MakeService = IntoMakeServiceWithConnectInfo<Router, net::SocketAddr>;
+
+static NULL_ADDR: net::SocketAddr = net::SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
+
 #[tracing::instrument(skip_all)]
-pub(super) async fn serve(
+pub(super) async fn serve(server: &Arc<Server>, app: Router, mut shutdown: broadcast::Receiver<()>) -> Result<()> {
-	server: &Arc<Server>, app: IntoMakeService<Router>, mut shutdown: broadcast::Receiver<()>,
-) -> Result<()> {
 	let mut tasks = JoinSet::<()>::new();
 	let executor = TokioExecutor::new();
+	let app = app.into_make_service_with_connect_info::<net::SocketAddr>();
 	let builder = server::conn::auto::Builder::new(executor);
 	let listener = init(server).await?;
 	loop {
@@ -46,14 +56,14 @@ pub(super) async fn serve(
 
 #[allow(clippy::let_underscore_must_use)]
 async fn accept(
-	server: &Arc<Server>, listener: &UnixListener, tasks: &mut JoinSet<()>, mut app: IntoMakeService<Router>,
+	server: &Arc<Server>, listener: &UnixListener, tasks: &mut JoinSet<()>, mut app: MakeService,
 	builder: server::conn::auto::Builder<TokioExecutor>, conn: (UnixStream, SocketAddr),
 ) {
 	let (socket, remote) = conn;
 	let socket = TokioIo::new(socket);
 	trace!(?listener, ?socket, ?remote, "accepted");
 
-	let called = unwrap_infallible(app.call(()).await);
+	let called = unwrap_infallible(app.call(NULL_ADDR).await);
 	let handler = service_fn(move |req: Request<Incoming>| called.clone().oneshot(req));
 
 	let task = async move {