remove b64 imgs

2 files changed, 58 insertions, 9 deletions

diff --git a/src/main.rs b/src/main.rs
index 74f0a0b..e8f17b0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,14 +5,13 @@ use axum::{
     response::Response,
     RequestExt, Router, extract::DefaultBodyLimit,
 };
-use axum_client_ip::ClientIp;
 use std::{net::SocketAddr, process::exit, fs};
 use tower_cookies::CookieManagerLayer;
 use tracing::{error, info, metadata::LevelFilter};
 use tracing_subscriber::{
     filter::filter_fn, prelude::__tracing_subscriber_SubscriberExt, util::SubscriberInitExt, Layer,
 };
-use types::http::ResponseCode;
+use types::{http::ResponseCode, extract::RequestIp};
 
 use crate::api::{pages, image};
 
@@ -38,7 +37,7 @@ async fn log<B>(mut req: Request<B>, next: Next<B>) -> Response
 where
     B: Send + Sync + 'static + HttpBody,
 {
-    let Ok(ClientIp(ip)) = req.extract_parts::<ClientIp>().await else {
+    let Ok(RequestIp(ip)) = req.extract_parts::<RequestIp>().await else {
         return next.run(req).await
     };
 
@@ -79,7 +78,7 @@ async fn main() {
         .layer(middleware::from_fn(serve))
         .nest("/", pages::router())
         .nest("/api", api::router())
-        .nest("/image", image::router())
+        .nest("/cdn", image::router())
         .layer(CookieManagerLayer::new())
         .layer(DefaultBodyLimit::max(512_000));
 
diff --git a/src/types/extract.rs b/src/types/extract.rs
index 54f250a..4d7ac51 100644
--- a/src/types/extract.rs
+++ b/src/types/extract.rs
@@ -1,14 +1,13 @@
-use std::io::{Read, Cursor};
+use std::{io::{Read, Cursor}, net::{IpAddr, SocketAddr}};
 
 use axum::{
     async_trait,
     body::HttpBody,
-    extract::{FromRequest, FromRequestParts},
+    extract::{FromRequest, FromRequestParts, ConnectInfo},
     http::{request::Parts, Request},
     response::Response,
     BoxError, RequestExt,
 };
-use axum_client_ip::ClientIp;
 use bytes::Bytes;
 use image::{io::Reader, ImageFormat, DynamicImage};
 use serde::de::DeserializeOwned;
@@ -23,6 +22,57 @@ use crate::{
     },
 };
 
+pub struct RequestIp(pub IpAddr);
+
+#[async_trait]
+impl<S> FromRequestParts<S> for RequestIp
+where
+    S: Send + Sync,
+{
+    type Rejection = Response;
+
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self> {
+
+        let headers = &parts.headers;
+
+        let forwardedfor = headers.get("x-forwarded-for")
+                        .and_then(|h| h.to_str().ok())
+                        .and_then(|h| 
+                            h.split(',')
+                            .rev()
+                            .find_map(|s| s.trim().parse::<IpAddr>().ok())
+                        );
+
+        if let Some(forwardedfor) = forwardedfor {
+            return Ok(RequestIp(forwardedfor))
+        }
+
+        let realip = headers.get("x-real-ip")
+                        .and_then(|hv| hv.to_str().ok())
+                        .and_then(|s| s.parse::<IpAddr>().ok());
+
+        if let Some(realip) = realip {
+            return Ok(RequestIp(realip))
+        }
+
+        let realip = headers.get("x-real-ip")
+                        .and_then(|hv| hv.to_str().ok())
+                        .and_then(|s| s.parse::<IpAddr>().ok());
+
+        if let Some(realip) = realip {
+            return Ok(RequestIp(realip))
+        }
+
+        let info = parts.extensions.get::<ConnectInfo<SocketAddr>>();
+
+        if let Some(info) = info {
+            return Ok(RequestIp(info.0.ip()))
+        }
+
+        Err(ResponseCode::Forbidden.text("You have no ip"))
+    }
+}
+
 pub struct AuthorizedUser(pub User);
 
 #[async_trait]
@@ -189,7 +239,7 @@ where
     S: Send + Sync,
 {
 
-    let Ok(ClientIp(ip)) = req.extract_parts::<ClientIp>().await else {
+    let Ok(RequestIp(ip)) = req.extract_parts::<RequestIp>().await else {
         tracing::error!("Failed to read client ip");
         return Err(ResponseCode::InternalServerError.text("Failed to read client ip"));
     };
@@ -224,7 +274,7 @@ where
     B::Error: Into<BoxError>,
     S: Send + Sync,
 {
-    let Ok(ClientIp(ip)) = req.extract_parts::<ClientIp>().await else {
+    let Ok(RequestIp(ip)) = req.extract_parts::<RequestIp>().await else {
         tracing::error!("Failed to read client ip");
         return Err(ResponseCode::InternalServerError.text("Failed to read client ip"));
     };