1 files changed, 161 insertions, 0 deletions
diff --git a/src/media.rs b/src/media.rs
new file mode 100644
index 0000000..2723816
--- /dev/null
+++ b/src/media.rs
@@ -0,0 +1,161 @@
+use actix_web::client::{Client, ClientResponse};
+use actix_web::error::{ErrorBadRequest, ErrorInternalServerError};
+use actix_web::http::header;
+use actix_web::{web, Error, HttpRequest, HttpResponse};
+
+use image::imageops::FilterType;
+use image::GenericImageView;
+use image::ImageFormat;
+
+use crate::SiteConfig;
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::resource("/media/photo/{width:\\d+}x{height:\\d+}/{filename}")
+            .route(web::get().to(serve_photo)),
+    );
+    cfg.service(
+        web::resource("/media/{type}/{filename:.+}")
+            .route(web::get().to(serve_file))
+            .route(web::head().to(serve_file)),
+    );
+}
+
+async fn serve_photo(
+    req: HttpRequest,
+    config: web::Data<SiteConfig>,
+    client: web::Data<Client>,
+) -> Result<HttpResponse, Error> {
+    let width = req
+        .match_info()
+        .get("width")
+        .ok_or(ErrorBadRequest("Bad URI"))
+        .and_then(|v| v.parse().map_err(|_| ErrorBadRequest("Bad URI")))?;
+    let height = req
+        .match_info()
+        .get("height")
+        .ok_or(ErrorBadRequest("Bad URI"))
+        .and_then(|v| v.parse().map_err(|_| ErrorBadRequest("Bad URI")))?;
+    let filename = req
+        .match_info()
+        .get("filename")
+        .ok_or(ErrorBadRequest("Bad URI"))?;
+
+    let new_url = format!("{}/photo/{}", config.media_url(), filename);
+
+    let forwarded_req = client.request_from(new_url, req.head());
+    let forwarded_req = if let Some(addr) = req.head().peer_addr {
+        forwarded_req.header("x-forwarded-for", format!("{}", addr.ip()))
+    } else {
+        forwarded_req
+    };
+
+    let mut res = forwarded_req.send().await.map_err(Error::from)?;
+
+    // Check response code
+    if !res.status().is_success() {
+        return forward_response(res).await;
+    }
+
+    // Get the payload, at at least 20 MB of it...
+    let data = res.body().limit(20971520).await?;
+
+    // Determine the image format
+    let fmt = image::guess_format(data.as_ref()).map_err(|e| ErrorInternalServerError(e))?;
+
+    // Parse the image
+    let img = image::load_from_memory_with_format(data.as_ref(), fmt)
+        .map_err(|e| ErrorInternalServerError(e))?;
+
+    let (orig_width, orig_height) = img.dimensions();
+
+    let scaled = if width < orig_width && height < orig_height {
+        // Take the largest size that maintains the aspect ratio
+        let ratio = orig_width as f64 / orig_height as f64;
+        let (new_width, new_height) = if width > height {
+            (width, (width as f64 / ratio) as u32)
+        } else {
+            ((height as f64 * ratio) as u32, height)
+        };
+        img.resize(new_width, new_height, FilterType::CatmullRom)
+    } else {
+        // We're not going to scale up images.
+        img
+    };
+
+    let mut new_data = Vec::new();
+    scaled
+        .write_to(&mut new_data, fmt) // ImageOutputFormat::Jpeg(128))
+        .map_err(|e| ErrorInternalServerError(e))?;
+
+    let mut client_resp = HttpResponse::build(res.status());
+    client_resp.set(header::CacheControl(vec![header::CacheDirective::MaxAge(
+        86400u32,
+    )]));
+    client_resp.set_header(header::CONTENT_TYPE, mime_for_image(fmt));
+
+    Ok(client_resp.body(new_data))
+}
+
+async fn serve_file(
+    req: HttpRequest,
+    config: web::Data<SiteConfig>,
+    client: web::Data<Client>,
+) -> Result<HttpResponse, Error> {
+    let media_type = req
+        .match_info()
+        .get("type")
+        .ok_or(ErrorBadRequest("Bad URI"))?;
+    let filename = req
+        .match_info()
+        .get("filename")
+        .ok_or(ErrorBadRequest("Bad URI"))?;
+
+    let new_url = format!("{}/{}/{}", config.media_url(), media_type, filename);
+
+    let forwarded_req = client.request_from(new_url, req.head()).no_decompress();
+
+    let forwarded_req = if let Some(addr) = req.head().peer_addr {
+        forwarded_req.header("x-forwarded-for", format!("{}", addr.ip()))
+    } else {
+        forwarded_req
+    };
+
+    let res = forwarded_req.send().await.map_err(Error::from)?;
+
+    forward_response(res).await
+}
+
+async fn forward_response<S>(mut res: ClientResponse<S>) -> Result<HttpResponse, Error>
+where
+    S: futures::Stream<Item = std::result::Result<bytes::Bytes, actix_web::error::PayloadError>>
+        + std::marker::Unpin,
+{
+    let mut client_resp = HttpResponse::build(res.status());
+
+    // Remove `Connection` as per
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection#Directives
+    for (header_name, header_value) in res.headers().iter().filter(|(h, _)| *h != "connection") {
+        client_resp.header(header_name.clone(), header_value.clone());
+    }
+
+    Ok(client_resp.body(res.body().limit(2147483648).await?))
+}
+
+fn mime_for_image(fmt: ImageFormat) -> &'static str {
+    match fmt {
+        ImageFormat::Png => "image/png",
+        ImageFormat::Jpeg => "image/jpeg",
+        ImageFormat::Gif => "image/gif",
+        ImageFormat::Tiff => "image/tiff",
+        ImageFormat::Ico => "image/vnd.microsoft.icon",
+        ImageFormat::WebP => "image/webp",
+        ImageFormat::Bmp => "image/bmp",
+        ImageFormat::Pnm => "image/x-portable-anymap",
+        ImageFormat::Tga => "image/x-tga",
+        ImageFormat::Dds => "image/vnd.ms-dds",
+        ImageFormat::Hdr => "image/vnd.radiance",
+        ImageFormat::Farbfeld => "image/farbfeld",
+        _ => "",
+    }
+}