Support listening on unix sockets (#9)

If `host` in the config fails to parse as an IP address it will trying
to bind to a Unix socket. Tested with Caddy and cURL by doing

cURL: `curl --unix-socket /tmp/calagopus.sock http://localhost/`
Caddy: `caddy reverse-proxy --from :8080 --to unix//tmp/calagopus.sock`

Author: Saturn745

application/src/commands/diagnostics.rs

@@ -187,7 +187,7 @@ pub async fn diagnostics(
                     .trim_start_matches("http://"),
                 "{redacted}",
             )
-            .replace(&config.api.host.to_string(), "{redacted}")
+            .replace(&config.api.host, "{redacted}")
             .replace(&config.system.sftp.bind_address.to_string(), "{redacted}");
 
         if !config.api.ssl.cert.is_empty() {

application/src/config.rs

@@ -19,8 +19,8 @@ use utoipa::ToSchema;
 fn app_name() -> String {
     "Pterodactyl".to_string()
 }
-fn api_host() -> std::net::IpAddr {
-    std::net::IpAddr::from([0, 0, 0, 0])
+fn api_host() -> String {
+    "0.0.0.0".to_string()
 }
 fn api_port() -> u16 {
     8080
@@ -440,8 +440,7 @@ nestify::nest! {
         #[schema(inline)]
         pub api: #[derive(ToSchema, Deserialize, Serialize, DefaultFromSerde)] #[serde(default)] pub struct Api {
             #[serde(default = "api_host")]
-            #[schema(value_type = String)]
-            pub host: std::net::IpAddr,
+            pub host: String,
             #[serde(default = "api_port")]
             pub port: u16,
 

application/src/main.rs

@@ -1,7 +1,7 @@
 use anyhow::Context;
 use axum::{
     body::Body,
-    extract::Request,
+    extract::{ConnectInfo, Request},
     http::{HeaderMap, HeaderValue, Method, Response, StatusCode},
     middleware::Next,
     response::IntoResponse,
@@ -590,74 +590,111 @@ async fn main() {
         }
     });
 
-    let address = SocketAddr::from((state.config.api.host, state.config.api.port));
+    if let Ok(host) = state.config.api.host.parse::<std::net::IpAddr>() {
+        let address = SocketAddr::from((host, state.config.api.port));
 
-    if config.api.ssl.enabled {
-        tracing::info!("loading ssl certs");
+        if config.api.ssl.enabled {
+            tracing::info!("loading ssl certs");
 
-        let config = axum_server::tls_rustls::RustlsConfig::from_pem_file(
-            config.api.ssl.cert.as_str(),
-            config.api.ssl.key.as_str(),
-        )
-        .await
-        .context("failed to load SSL certificate and key")
-        .unwrap();
+            let config = axum_server::tls_rustls::RustlsConfig::from_pem_file(
+                config.api.ssl.cert.as_str(),
+                config.api.ssl.key.as_str(),
+            )
+            .await
+            .context("failed to load SSL certificate and key")
+            .unwrap();
 
-        tracing::info!(
-            "{} listening on {}",
-            "https server".bright_red(),
-            address.to_string().cyan(),
-        );
+            tracing::info!(
+                "{} listening on {}",
+                "https server".bright_red(),
+                address.to_string().cyan(),
+            );
 
-        match axum_server::bind_rustls(address, config)
-            .serve(router.into_make_service_with_connect_info::<SocketAddr>())
-            .await
-        {
-            Ok(_) => {}
-            Err(err) => {
-                if err.kind() == std::io::ErrorKind::AddrInUse {
-                    tracing::error!("failed to start https server (address already in use)");
-                } else {
-                    tracing::error!("failed to start https server: {:?}", err,);
-                }
+            match axum_server::bind_rustls(address, config)
+                .serve(router.into_make_service_with_connect_info::<SocketAddr>())
+                .await
+            {
+                Ok(_) => {}
+                Err(err) => {
+                    if err.kind() == std::io::ErrorKind::AddrInUse {
+                        tracing::error!("failed to start https server (address already in use)");
+                    } else {
+                        tracing::error!("failed to start https server: {:?}", err,);
+                    }
 
-                std::process::exit(1);
+                    std::process::exit(1);
+                }
             }
-        }
-    } else {
-        tracing::info!(
-            "{} listening on {}",
-            "http server".bright_red(),
-            address.to_string().cyan(),
-        );
+        } else {
+            tracing::info!(
+                "{} listening on {}",
+                "http server".bright_red(),
+                address.to_string().cyan(),
+            );
 
-        match axum::serve(
-            match tokio::net::TcpListener::bind(address).await {
-                Ok(listener) => listener,
+            match axum::serve(
+                match tokio::net::TcpListener::bind(address).await {
+                    Ok(listener) => listener,
+                    Err(err) => {
+                        if err.kind() == std::io::ErrorKind::AddrInUse {
+                            tracing::error!("failed to start http server (address already in use)");
+                            std::process::exit(1);
+                        } else {
+                            tracing::error!("failed to start http server: {:?}", err);
+                            std::process::exit(1);
+                        }
+                    }
+                },
+                router.into_make_service_with_connect_info::<SocketAddr>(),
+            )
+            .await
+            {
+                Ok(_) => {}
                 Err(err) => {
                     if err.kind() == std::io::ErrorKind::AddrInUse {
                         tracing::error!("failed to start http server (address already in use)");
-                        std::process::exit(1);
                     } else {
                         tracing::error!("failed to start http server: {:?}", err);
-                        std::process::exit(1);
                     }
+
+                    std::process::exit(1);
                 }
-            },
-            router.into_make_service_with_connect_info::<SocketAddr>(),
-        )
-        .await
+            }
+        }
+    } else {
+        #[cfg(unix)]
         {
-            Ok(_) => {}
-            Err(err) => {
-                if err.kind() == std::io::ErrorKind::AddrInUse {
-                    tracing::error!("failed to start http server (address already in use)");
-                } else {
-                    tracing::error!("failed to start http server: {:?}", err);
-                }
+            let socket_path = &state.config.api.host;
 
-                std::process::exit(1);
-            }
+            tracing::info!(
+                "{} listening on {}",
+                "http server".bright_red(),
+                socket_path.cyan(),
+            );
+
+            let router = router.layer(axum::middleware::from_fn(
+                |mut req: Request, next: Next| async move {
+                    req.extensions_mut().insert(ConnectInfo(SocketAddr::from((
+                        std::net::IpAddr::from([127, 0, 0, 1]),
+                        0,
+                    ))));
+                    next.run(req).await
+                },
+            ));
+
+            let _ = tokio::fs::remove_file(socket_path).await;
+
+            let listener = tokio::net::UnixListener::bind(socket_path).unwrap();
+
+            axum::serve(listener, router.into_make_service())
+                .await
+                .unwrap();
+        }
+
+        #[cfg(not(unix))]
+        {
+            tracing::error!("unix socket support is only available on unix systems");
+            std::process::exit(1);
         }
     }
 }

application/src/routes/api/update.rs

@@ -17,8 +17,7 @@ mod post {
 
             #[schema(inline)]
             api: Option<#[derive(ToSchema, Deserialize)] pub struct ApiPayload {
-                #[schema(value_type = Option<String>)]
-                host: Option<std::net::IpAddr>,
+                host: Option<String>,
                 port: Option<u16>,
 
                 #[schema(inline)]