Properly handle Content-Type

plume-models/src/medias.rs

@@ -294,6 +294,8 @@ impl Media {
 
             #[cfg(feature = "s3")]
             {
+                use rocket::http::ContentType;
+
                 let dest = determine_mirror_s3_path(&remote_url);
 
                 let media = request::get(
@@ -301,18 +303,22 @@ impl Media {
                     User::get_sender(),
                     CONFIG.proxy().cloned(),
                 )?;
-                let content_type = media.headers().get(reqwest::header::CONTENT_TYPE).cloned();
+
+                let content_type = media
+                    .headers()
+                    .get(reqwest::header::CONTENT_TYPE)
+                    .and_then(|x| x.to_str().ok())
+                    .and_then(ContentType::parse_flexible)
+                    .unwrap_or(ContentType::Binary);
+
                 let bytes = media.bytes()?;
 
                 let bucket = CONFIG.s3.as_ref().unwrap().get_bucket();
-                match content_type.as_ref().and_then(|x| x.to_str().ok()) {
+                bucket.put_object_with_content_type_blocking(
-                    Some(ct) => {
+                    &dest,
-                        bucket.put_object_with_content_type_blocking(&dest, &bytes, ct)?;
+                    &bytes,
-                    }
+                    &content_type.to_string()
-                    None => {
+                )?;
-                        bucket.put_object_blocking(&dest, &bytes)?;
-                    }
-                }
 
                 dest
             }

src/routes/medias.rs

@@ -131,14 +131,14 @@ fn save_uploaded_file(file: &SavedField) -> Result<Option<String>, plume_models:
             };
 
             let bucket = CONFIG.s3.as_ref().unwrap().get_bucket();
-            match &file.headers.content_type {
+            let content_type = match &file.headers.content_type {
-                Some(ct) => {
+                Some(ct) => ct.to_string(),
-                    bucket.put_object_with_content_type_blocking(&dest, &bytes, &ct.to_string())?;
+                None => ContentType::from_extension(&ext)
-                }
+                    .unwrap_or(ContentType::Binary)
-                None => {
+                    .to_string(),
-                    bucket.put_object_blocking(&dest, &bytes)?;
+            };
-                }
+
-            }
+            bucket.put_object_with_content_type_blocking(&dest, &bytes, &content_type)?;
 
             Ok(Some(dest))
         }

src/routes/mod.rs

@@ -269,13 +269,15 @@ pub fn plume_media_files(file: PathBuf) -> Option<CachedFile> {
 
         #[cfg(feature="s3")]
         {
-            let ct = file.extension()
-                .and_then(|ext| ContentType::from_extension(&ext.to_string_lossy()))
-                .unwrap_or(ContentType::Binary);
-
             let data = CONFIG.s3.as_ref().unwrap().get_bucket()
                 .get_object_blocking(format!("static/media/{}", file.to_string_lossy())).ok()?;
 
+            let ct = data.headers().get("content-type")
+                .and_then(|x| ContentType::parse_flexible(&x))
+                .or_else(|| file.extension()
+                    .and_then(|ext| ContentType::from_extension(&ext.to_string_lossy())))
+                .unwrap_or(ContentType::Binary);
+
             Some(CachedFile {
                 inner: FileKind::S3 ( data.to_vec(), ct),
                 cache_control: CacheControl(vec![CacheDirective::MaxAge(60 * 60 * 24 * 30)]),