1use core::cmp::max;
4use std::io::{Cursor, Seek};
5use std::iter::FusedIterator;
6use std::mem;
7use std::path::{Path, PathBuf};
8
9use anyhow::{Context as _, Result, ensure, format_err};
10use base64::Engine as _;
11use futures::StreamExt;
12use image::ImageReader;
13use image::codecs::jpeg::JpegEncoder;
14use image::{DynamicImage, GenericImage, GenericImageView, ImageFormat, Pixel, Rgba};
15use num_traits::FromPrimitive;
16use tokio::{fs, task};
17use tokio_stream::wrappers::ReadDirStream;
18
19use crate::config::Config;
20use crate::constants::{self, MediaQuality};
21use crate::context::Context;
22use crate::events::EventType;
23use crate::log::{LogExt, error, info, warn};
24use crate::message::Viewtype;
25use crate::tools::sanitize_filename;
26
27#[derive(Debug, Clone, PartialEq, Eq)]
34pub struct BlobObject<'a> {
35 blobdir: &'a Path,
36
37 name: String,
41}
42
43#[derive(Debug, Clone)]
44enum ImageOutputFormat {
45 Png,
46 Jpeg { quality: u8 },
47}
48
49impl<'a> BlobObject<'a> {
50 pub fn create_and_deduplicate(
61 context: &'a Context,
62 src: &Path,
63 original_name: &Path,
64 ) -> Result<BlobObject<'a>> {
65 task::block_in_place(|| {
70 let temp_path;
71 let src_in_blobdir: &Path;
72 let blobdir = context.get_blobdir();
73
74 if src.starts_with(blobdir) {
75 src_in_blobdir = src;
76 } else {
77 info!(
78 context,
79 "Source file not in blobdir. Copying instead of moving in order to prevent moving a file that was still needed."
80 );
81 temp_path = blobdir.join(format!("tmp-{}", rand::random::<u64>()));
82 if std::fs::copy(src, &temp_path).is_err() {
83 std::fs::create_dir_all(blobdir).log_err(context).ok();
85 std::fs::copy(src, &temp_path).context("Copying new blobfile failed")?;
86 };
87 src_in_blobdir = &temp_path;
88 }
89
90 let hash = file_hash(src_in_blobdir)?.to_hex();
91 let hash = hash.as_str();
92 let hash = hash.get(0..31).unwrap_or(hash);
93 let new_file =
94 if let Some(extension) = original_name.extension().filter(|e| e.len() <= 32) {
95 let extension = extension.to_string_lossy().to_lowercase();
96 let extension = sanitize_filename(&extension);
97 format!("$BLOBDIR/{hash}.{extension}")
98 } else {
99 format!("$BLOBDIR/{hash}")
100 };
101
102 let blob = BlobObject {
103 blobdir,
104 name: new_file,
105 };
106 let new_path = blob.to_abs_path();
107
108 std::fs::rename(src_in_blobdir, &new_path)?;
111
112 context.emit_event(EventType::NewBlobFile(blob.as_name().to_string()));
113 Ok(blob)
114 })
115 }
116
117 pub fn create_and_deduplicate_from_bytes(
127 context: &'a Context,
128 data: &[u8],
129 original_name: &str,
130 ) -> Result<BlobObject<'a>> {
131 task::block_in_place(|| {
132 let blobdir = context.get_blobdir();
133 let temp_path = blobdir.join(format!("tmp-{}", rand::random::<u64>()));
134 if std::fs::write(&temp_path, data).is_err() {
135 std::fs::create_dir_all(blobdir).log_err(context).ok();
137 std::fs::write(&temp_path, data).context("writing new blobfile failed")?;
138 };
139
140 BlobObject::create_and_deduplicate(context, &temp_path, Path::new(original_name))
141 })
142 }
143
144 pub fn from_path(context: &'a Context, path: &Path) -> Result<BlobObject<'a>> {
151 let rel_path = path
152 .strip_prefix(context.get_blobdir())
153 .with_context(|| format!("wrong blobdir: {}", path.display()))?;
154 let name = rel_path.to_str().context("wrong name")?;
155 if !BlobObject::is_acceptible_blob_name(name) {
156 return Err(format_err!("bad blob name: {}", rel_path.display()));
157 }
158 BlobObject::from_name(context, name)
159 }
160
161 pub fn from_name(context: &'a Context, name: &str) -> Result<BlobObject<'a>> {
168 let name = match name.starts_with("$BLOBDIR/") {
169 true => name.splitn(2, '/').last().unwrap(),
170 false => name,
171 };
172 if !BlobObject::is_acceptible_blob_name(name) {
173 return Err(format_err!("not an acceptable blob name: {}", name));
174 }
175 Ok(BlobObject {
176 blobdir: context.get_blobdir(),
177 name: format!("$BLOBDIR/{name}"),
178 })
179 }
180
181 pub fn to_abs_path(&self) -> PathBuf {
183 let fname = Path::new(&self.name).strip_prefix("$BLOBDIR/").unwrap();
184 self.blobdir.join(fname)
185 }
186
187 #[allow(rustdoc::private_intra_doc_links)]
198 pub fn as_name(&self) -> &str {
200 &self.name
201 }
202
203 pub fn suffix(&self) -> Option<&str> {
208 let ext = self.name.rsplit('.').next();
209 if ext == Some(&self.name) { None } else { ext }
210 }
211
212 fn is_acceptible_blob_name(name: &str) -> bool {
220 if name.find('/').is_some() {
221 return false;
222 }
223 if name.find('\\').is_some() {
224 return false;
225 }
226 if name.find('\0').is_some() {
227 return false;
228 }
229 true
230 }
231
232 pub(crate) fn store_from_base64(context: &Context, data: &str) -> Result<String> {
238 let buf = base64::engine::general_purpose::STANDARD.decode(data)?;
239 let name = if let Ok(format) = image::guess_format(&buf) {
240 if let Some(ext) = format.extensions_str().first() {
241 format!("file.{ext}")
242 } else {
243 String::new()
244 }
245 } else {
246 String::new()
247 };
248 let blob = BlobObject::create_and_deduplicate_from_bytes(context, &buf, &name)?;
249 Ok(blob.as_name().to_string())
250 }
251
252 pub async fn recode_to_avatar_size(&mut self, context: &Context) -> Result<()> {
254 let (img_wh, max_bytes) =
255 match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
256 .unwrap_or_default()
257 {
258 MediaQuality::Balanced => (
259 constants::BALANCED_AVATAR_SIZE,
260 constants::BALANCED_AVATAR_BYTES,
261 ),
262 MediaQuality::Worse => {
263 (constants::WORSE_AVATAR_SIZE, constants::WORSE_AVATAR_BYTES)
264 }
265 };
266
267 let viewtype = &mut Viewtype::Image;
268 let is_avatar = true;
269 self.check_or_recode_to_size(
270 context, None, viewtype, img_wh, max_bytes, is_avatar,
272 )?;
273
274 Ok(())
275 }
276
277 pub async fn check_or_recode_image(
287 &mut self,
288 context: &Context,
289 name: Option<String>,
290 viewtype: &mut Viewtype,
291 ) -> Result<String> {
292 let (img_wh, max_bytes) =
293 match MediaQuality::from_i32(context.get_config_int(Config::MediaQuality).await?)
294 .unwrap_or_default()
295 {
296 MediaQuality::Balanced => (
297 constants::BALANCED_IMAGE_SIZE,
298 constants::BALANCED_IMAGE_BYTES,
299 ),
300 MediaQuality::Worse => (constants::WORSE_IMAGE_SIZE, constants::WORSE_IMAGE_BYTES),
301 };
302 let is_avatar = false;
303 self.check_or_recode_to_size(context, name, viewtype, img_wh, max_bytes, is_avatar)
304 }
305
306 fn check_or_recode_to_size(
318 &mut self,
319 context: &Context,
320 name: Option<String>,
321 viewtype: &mut Viewtype,
322 mut img_wh: u32,
323 max_bytes: usize,
324 is_avatar: bool,
325 ) -> Result<String> {
326 let mut add_white_bg = is_avatar;
328 let mut no_exif = false;
329 let no_exif_ref = &mut no_exif;
330 let mut name = name.unwrap_or_else(|| self.name.clone());
331 let original_name = name.clone();
332 let vt = &mut *viewtype;
333 let res: Result<String> = tokio::task::block_in_place(move || {
334 let mut file = std::fs::File::open(self.to_abs_path())?;
335 let (nr_bytes, exif) = image_metadata(&file)?;
336 *no_exif_ref = exif.is_none();
337 file.rewind()?;
340 let imgreader = ImageReader::new(std::io::BufReader::new(&file)).with_guessed_format();
341 let imgreader = match imgreader {
342 Ok(ir) => ir,
343 _ => {
344 file.rewind()?;
345 ImageReader::with_format(
346 std::io::BufReader::new(&file),
347 ImageFormat::from_path(self.to_abs_path())?,
348 )
349 }
350 };
351 let fmt = imgreader.format().context("Unknown format")?;
352 if *vt == Viewtype::File {
353 *vt = Viewtype::Image;
354 return Ok(name);
355 }
356 let mut img = imgreader.decode().context("image decode failure")?;
357 let orientation = exif.as_ref().map(|exif| exif_orientation(exif, context));
358 let mut encoded = Vec::new();
359
360 if *vt == Viewtype::Sticker {
361 let x_max = img.width().saturating_sub(1);
362 let y_max = img.height().saturating_sub(1);
363 if !img.in_bounds(x_max, y_max)
364 || !(img.get_pixel(0, 0).0[3] == 0
365 || img.get_pixel(x_max, 0).0[3] == 0
366 || img.get_pixel(0, y_max).0[3] == 0
367 || img.get_pixel(x_max, y_max).0[3] == 0)
368 {
369 *vt = Viewtype::Image;
370 }
371 }
372 if *vt == Viewtype::Sticker && exif.is_none() {
373 return Ok(name);
374 }
375
376 img = match orientation {
377 Some(90) => img.rotate90(),
378 Some(180) => img.rotate180(),
379 Some(270) => img.rotate270(),
380 _ => img,
381 };
382
383 let exceeds_wh = img.width() > img_wh || img.height() > img_wh;
384 let exceeds_max_bytes = nr_bytes > max_bytes as u64;
385
386 let jpeg_quality = 75;
387 let ofmt = match fmt {
388 ImageFormat::Png if !exceeds_max_bytes => ImageOutputFormat::Png,
389 ImageFormat::Jpeg => {
390 add_white_bg = false;
391 ImageOutputFormat::Jpeg {
392 quality: jpeg_quality,
393 }
394 }
395 _ => ImageOutputFormat::Jpeg {
396 quality: jpeg_quality,
397 },
398 };
399 let do_scale = exceeds_max_bytes
406 || is_avatar
407 && (exceeds_wh
408 || exif.is_some() && {
409 if mem::take(&mut add_white_bg) {
410 self::add_white_bg(&mut img);
411 }
412 encoded_img_exceeds_bytes(
413 context,
414 &img,
415 ofmt.clone(),
416 max_bytes,
417 &mut encoded,
418 )?
419 });
420
421 if do_scale {
422 if !exceeds_wh {
423 img_wh = max(img.width(), img.height());
424 if matches!(fmt, ImageFormat::Jpeg) || !encoded.is_empty() {
427 img_wh = img_wh * 2 / 3;
428 }
429 }
430
431 loop {
432 if mem::take(&mut add_white_bg) {
433 self::add_white_bg(&mut img);
434 }
435
436 let new_img = if is_avatar {
445 img.resize(img_wh, img_wh, image::imageops::FilterType::Triangle)
446 } else {
447 img.thumbnail(img_wh, img_wh)
448 };
449
450 if encoded_img_exceeds_bytes(
451 context,
452 &new_img,
453 ofmt.clone(),
454 max_bytes,
455 &mut encoded,
456 )? && is_avatar
457 {
458 if img_wh < 20 {
459 return Err(format_err!(
460 "Failed to scale image to below {}B.",
461 max_bytes,
462 ));
463 }
464
465 img_wh = img_wh * 2 / 3;
466 } else {
467 info!(
468 context,
469 "Final scaled-down image size: {}B ({}px).",
470 encoded.len(),
471 img_wh
472 );
473 break;
474 }
475 }
476 }
477
478 if do_scale || exif.is_some() {
479 if !matches!(fmt, ImageFormat::Jpeg)
481 && matches!(ofmt, ImageOutputFormat::Jpeg { .. })
482 {
483 name = Path::new(&name)
484 .with_extension("jpg")
485 .to_string_lossy()
486 .into_owned();
487 }
488
489 if encoded.is_empty() {
490 if mem::take(&mut add_white_bg) {
491 self::add_white_bg(&mut img);
492 }
493 encode_img(&img, ofmt, &mut encoded)?;
494 }
495
496 self.name = BlobObject::create_and_deduplicate_from_bytes(context, &encoded, &name)
497 .context("failed to write recoded blob to file")?
498 .name;
499 }
500
501 Ok(name)
502 });
503 match res {
504 Ok(_) => res,
505 Err(err) => {
506 if !is_avatar && no_exif {
507 error!(
508 context,
509 "Cannot check/recode image, using original data: {err:#}.",
510 );
511 *viewtype = Viewtype::File;
512 Ok(original_name)
513 } else {
514 Err(err)
515 }
516 }
517 }
518 }
519}
520
521fn file_hash(src: &Path) -> Result<blake3::Hash> {
522 ensure!(
523 !src.starts_with("$BLOBDIR/"),
524 "Use `get_abs_path()` to get the absolute path of the blobfile"
525 );
526 let mut hasher = blake3::Hasher::new();
527 let mut src_file = std::fs::File::open(src)
528 .with_context(|| format!("Failed to open file {}", src.display()))?;
529 hasher
530 .update_reader(&mut src_file)
531 .context("update_reader")?;
532 let hash = hasher.finalize();
533 Ok(hash)
534}
535
536fn image_metadata(file: &std::fs::File) -> Result<(u64, Option<exif::Exif>)> {
538 let len = file.metadata()?.len();
539 let mut bufreader = std::io::BufReader::new(file);
540 let exif = exif::Reader::new().read_from_container(&mut bufreader).ok();
541 Ok((len, exif))
542}
543
544fn exif_orientation(exif: &exif::Exif, context: &Context) -> i32 {
545 if let Some(orientation) = exif.get_field(exif::Tag::Orientation, exif::In::PRIMARY) {
546 match orientation.value.get_uint(0) {
549 Some(3) => return 180,
550 Some(6) => return 90,
551 Some(8) => return 270,
552 other => warn!(context, "Exif orientation value ignored: {other:?}."),
553 }
554 }
555 0
556}
557
558pub(crate) struct BlobDirContents<'a> {
565 inner: Vec<PathBuf>,
566 context: &'a Context,
567}
568
569impl<'a> BlobDirContents<'a> {
570 pub(crate) async fn new(context: &'a Context) -> Result<BlobDirContents<'a>> {
571 let readdir = fs::read_dir(context.get_blobdir()).await?;
572 let inner = ReadDirStream::new(readdir)
573 .filter_map(|entry| async move {
574 match entry {
575 Ok(entry) => Some(entry),
576 Err(err) => {
577 error!(context, "Failed to read blob file: {err}.");
578 None
579 }
580 }
581 })
582 .filter_map(|entry| async move {
583 match entry.file_type().await.ok()?.is_file() {
584 true => Some(entry.path()),
585 false => {
586 warn!(
587 context,
588 "Export: Found blob dir entry {} that is not a file, ignoring.",
589 entry.path().display()
590 );
591 None
592 }
593 }
594 })
595 .collect()
596 .await;
597 Ok(Self { inner, context })
598 }
599
600 pub(crate) fn iter(&self) -> BlobDirIter<'_> {
601 BlobDirIter::new(self.context, self.inner.iter())
602 }
603}
604
605pub(crate) struct BlobDirIter<'a> {
607 iter: std::slice::Iter<'a, PathBuf>,
608 context: &'a Context,
609}
610
611impl<'a> BlobDirIter<'a> {
612 fn new(context: &'a Context, iter: std::slice::Iter<'a, PathBuf>) -> BlobDirIter<'a> {
613 Self { iter, context }
614 }
615}
616
617impl<'a> Iterator for BlobDirIter<'a> {
618 type Item = BlobObject<'a>;
619
620 fn next(&mut self) -> Option<Self::Item> {
621 for path in self.iter.by_ref() {
622 match BlobObject::from_path(self.context, path) {
625 Ok(blob) => return Some(blob),
626 Err(err) => warn!(self.context, "{err}"),
627 }
628 }
629 None
630 }
631}
632
633impl FusedIterator for BlobDirIter<'_> {}
634
635fn encode_img(
636 img: &DynamicImage,
637 fmt: ImageOutputFormat,
638 encoded: &mut Vec<u8>,
639) -> anyhow::Result<()> {
640 encoded.clear();
641 let mut buf = Cursor::new(encoded);
642 match fmt {
643 ImageOutputFormat::Png => img.write_to(&mut buf, ImageFormat::Png)?,
644 ImageOutputFormat::Jpeg { quality } => {
645 let encoder = JpegEncoder::new_with_quality(&mut buf, quality);
646 img.clone().into_rgb8().write_with_encoder(encoder)?;
650 }
651 }
652 Ok(())
653}
654
655fn encoded_img_exceeds_bytes(
656 context: &Context,
657 img: &DynamicImage,
658 fmt: ImageOutputFormat,
659 max_bytes: usize,
660 encoded: &mut Vec<u8>,
661) -> anyhow::Result<bool> {
662 encode_img(img, fmt, encoded)?;
663 if encoded.len() > max_bytes {
664 info!(
665 context,
666 "Image size {}B ({}x{}px) exceeds {}B, need to scale down.",
667 encoded.len(),
668 img.width(),
669 img.height(),
670 max_bytes,
671 );
672 return Ok(true);
673 }
674 Ok(false)
675}
676
677fn add_white_bg(img: &mut DynamicImage) {
679 for y in 0..img.height() {
680 for x in 0..img.width() {
681 let mut p = Rgba([255u8, 255, 255, 255]);
682 p.blend(&img.get_pixel(x, y));
683 img.put_pixel(x, y, p);
684 }
685 }
686}
687
688#[cfg(test)]
689mod blob_tests;