//! Load images from local paths or `http(s)://` URLs. use std::collections::HashMap; use std::io::Read; use std::path::{Path, PathBuf}; use std::sync::{Mutex, OnceLock}; use std::time::Duration; use image::DynamicImage; const MAX_DOWNLOAD_BYTES: u64 = 5 * 1024 * 1024; const DOWNLOAD_TIMEOUT_SECS: u64 = 10; #[derive(Debug)] pub enum ImageLoadError { Message(String), } impl std::fmt::Display for ImageLoadError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Message(m) => write!(f, "{m}"), } } } impl std::error::Error for ImageLoadError {} fn cache() -> std::sync::MutexGuard<'static, HashMap>> { static CACHE: OnceLock>>> = OnceLock::new(); CACHE .get_or_init(|| Mutex::new(HashMap::new())) .lock() .unwrap_or_else(|e| e.into_inner()) } pub fn is_http_url(path: &str) -> bool { let lower = path.trim().to_ascii_lowercase(); lower.starts_with("https://") || lower.starts_with("http://") } /// Open a local image path or download an `http`/`https` URL (cached per process). pub fn load_image(path: &str, base_dir: Option<&Path>) -> Result { let path = path.trim(); if path.is_empty() { return Err(ImageLoadError::Message("image path is empty".into())); } if is_http_url(path) { let bytes = download_cached(path)?; return image::load_from_memory(&bytes) .map_err(|e| ImageLoadError::Message(format!("decode {path}: {e}"))); } if path.contains("://") { return Err(ImageLoadError::Message(format!( "unsupported image URL scheme (only http/https): {path}" ))); } let resolved = resolve_image_path(path, base_dir); image::open(&resolved).map_err(|e| ImageLoadError::Message(format!("image {path}: {e}"))) } fn download_cached(url: &str) -> Result, ImageLoadError> { { let guard = cache(); if let Some(bytes) = guard.get(url) { return Ok(bytes.clone()); } } let bytes = download(url)?; cache().insert(url.to_string(), bytes.clone()); Ok(bytes) } fn download(url: &str) -> Result, ImageLoadError> { // Accept certificates the rustls/webpki bundle does not know (corporate CAs, // incomplete chains). Remote logos on POS templates often live on such hosts. let tls = native_tls::TlsConnector::builder() .danger_accept_invalid_certs(true) .danger_accept_invalid_hostnames(true) .build() .map_err(|e| ImageLoadError::Message(format!("tls setup: {e}")))?; let agent = ureq::AgentBuilder::new() .tls_connector(std::sync::Arc::new(tls)) .timeout_connect(Duration::from_secs(DOWNLOAD_TIMEOUT_SECS)) .timeout_read(Duration::from_secs(DOWNLOAD_TIMEOUT_SECS)) .build(); let response = agent .get(url) .call() .map_err(|e| ImageLoadError::Message(format!("download {url}: {e}")))?; let len = response .header("Content-Length") .and_then(|v| v.parse::().ok()); if let Some(len) = len { if len > MAX_DOWNLOAD_BYTES { return Err(ImageLoadError::Message(format!( "download {url}: Content-Length {len} exceeds {MAX_DOWNLOAD_BYTES} byte limit" ))); } } let mut reader = response.into_reader().take(MAX_DOWNLOAD_BYTES + 1); let mut bytes = Vec::new(); reader .read_to_end(&mut bytes) .map_err(|e| ImageLoadError::Message(format!("download {url}: {e}")))?; if bytes.len() as u64 > MAX_DOWNLOAD_BYTES { return Err(ImageLoadError::Message(format!( "download {url}: response exceeds {MAX_DOWNLOAD_BYTES} byte limit" ))); } Ok(bytes) } pub fn resolve_image_path(path: &str, base_dir: Option<&Path>) -> PathBuf { let p = Path::new(path); if p.is_absolute() { p.to_path_buf() } else if let Some(base) = base_dir { base.join(p) } else { p.to_path_buf() } } #[cfg(test)] mod tests { use super::*; #[test] fn detects_http_urls() { assert!(is_http_url("https://example.com/a.png")); assert!(is_http_url("http://example.com/a.png")); assert!(!is_http_url("logo.png")); assert!(!is_http_url("file:///tmp/a.png")); } #[test] fn rejects_non_http_schemes() { let err = load_image("file:///tmp/x.png", None).unwrap_err(); assert!(err.to_string().contains("unsupported")); } }