#![allow(dead_code)]
use serde_json::Value;
use std::fs;
use std::path::Path;
use std::collections::HashMap;
fn detect_encoding(data: &[u8]) -> String {
if data.is_empty() {
return "text".to_string();
}
let limit = std::cmp::min(data.len(), 4096);
let sample = &data[..limit];
if sample.contains(&0) {
return "binary".to_string();
}
let mut non_text_count = 0;
for &b in sample {
if b < 9 || (b > 13 && b < 32) || b > 127 {
non_text_count += 1;
}
}
if non_text_count > (sample.len() * 30 / 100) {
"binary".to_string()
} else {
"text".to_string()
}
}
pub fn is_binary(data: &[u8]) -> bool {
detect_encoding(data) == "binary"
}
fn get_magic_rules(clm_root: &str) -> HashMap<String, String> {
let mut magic_rules = HashMap::new();
let types_dir = Path::new(clm_root).join("types");
if !types_dir.exists() {
return magic_rules;
}
let walk_dir = |dir: &Path, rules: &mut HashMap<String, String>| {
if let Ok(entries) = fs::read_dir(dir) {
for entry in entries.flatten() {
let path = entry.path();
if path.is_file()
&& let Some(ext) = path.extension().and_then(|s| s.to_str())
&& (ext == "yaml" || ext == "clm")
&& let Ok(content) = fs::read_to_string(&path)
&& let Ok(val) = serde_yaml::from_str::<Value>(&content) {
let inner = val.get("clm").unwrap_or(&val);
if let Some(concrete) = inner.get("concrete_impl").or_else(|| inner.get("concrete"))
&& let Some(content_type) = concrete.get("content_type") {
let mime = content_type.get("mime").and_then(|v| v.as_str()).unwrap_or_default();
let magic_bytes_str = content_type.get("detection_rules")
.and_then(|v| v.get("magic_bytes"))
.and_then(|v| v.as_str())
.unwrap_or_default();
if !mime.is_empty() && !magic_bytes_str.is_empty() {
rules.insert(magic_bytes_str.to_lowercase(), mime.to_string());
}
}
}
}
}
};
for folder in &["content", "transport", "meta"] {
walk_dir(&types_dir.join(folder), &mut magic_rules);
}
magic_rules
}
fn lookup_ext_hint(ext_hint: &str) -> Option<&'static str> {
if ext_hint.is_empty() {
return None;
}
let clean_hint = ext_hint.trim_start_matches('.').to_lowercase();
let ext_map = [
("md", "text/markdown"),
("py", "text/x-python"),
("sh", "text/x-shellscript"),
("js", "application/javascript"),
("yaml", "application/yaml"),
("yml", "application/yaml"),
("json", "application/json"),
("xml", "text/xml"),
("html", "text/html"),
("htm", "text/html"),
("svg", "image/svg+xml"),
("stl", "model/stl"),
("obj", "model/obj"),
("dxf", "image/vnd.dxf"),
("gltf", "model/gltf+json"),
("tex", "text/x-tex"),
("tikz", "text/x-tikz"),
("tikzcd", "text/x-tikzcd"),
("tikz-cd", "text/x-tikzcd"),
("djvu", "image/vnd.djvu"),
("djv", "image/vnd.djvu"),
("geojson", "application/geo+json"),
("kml", "application/vnd.google-earth.kml+xml"),
("shp", "application/x-shapefile"),
("gpkg", "application/geopackage+sqlite3"),
];
for &(ext, mime) in &ext_map {
if clean_hint == ext {
return Some(mime);
}
}
None
}
pub fn detect_mime(data: &[u8], ext_hint: &str, clm_root: &str) -> String {
if data.is_empty() {
if let Some(mime) = lookup_ext_hint(ext_hint) {
return mime.to_string();
}
return "application/octet-stream".to_string();
}
let limit = std::cmp::min(data.len(), 16);
let header_bytes = &data[..limit];
let hex_header = header_bytes.iter().map(|b| format!("{:02x}", b)).collect::<String>();
let mut magic_rules = get_magic_rules(clm_root);
let static_magic = [
("89504e470d0a1a0a", "image/png"),
("ffd8ffe0", "image/jpeg"),
("ffd8ffe1", "image/jpeg"),
("ffd8ffe2", "image/jpeg"),
("ffd8ffe3", "image/jpeg"),
("ffd8ffe8", "image/jpeg"),
("474946383761", "image/gif"),
("474946383961", "image/gif"),
("25504446", "application/pdf"),
("504b0304", "application/zip"),
("53514c69746520666f726d6174203300", "application/sqlite3"),
];
for &(k, v) in &static_magic {
if !magic_rules.contains_key(k) {
magic_rules.insert(k.to_string(), v.to_string());
}
}
let mut sorted_rules: Vec<_> = magic_rules.into_iter().collect();
sorted_rules.sort_by_key(|a| std::cmp::Reverse(a.0.len()));
for (magic_hex, mime) in sorted_rules {
if hex_header.starts_with(&magic_hex) {
return mime;
}
}
if let Some(mime) = lookup_ext_hint(ext_hint) {
return mime.to_string();
}
if is_binary(data) {
"application/octet-stream".to_string()
} else {
"text/plain".to_string()
}
}
fn hex_to_bytes(hex: &str) -> Option<Vec<u8>> {
let mut bytes = Vec::new();
let mut chars = hex.chars().peekable();
while let Some(c1) = chars.next() {
if let Some(&c2) = chars.peek() {
chars.next();
let byte_str = format!("{}{}", c1, c2);
if let Ok(b) = u8::from_str_radix(&byte_str, 16) {
bytes.push(b);
} else {
return None;
}
} else {
return None;
}
}
bytes.into()
}
pub fn validate(clm_root: &str, file_path: &str, mime: Option<&str>) -> bool {
let path = Path::new(file_path);
if !path.exists() || !path.is_file() {
return false;
}
let data = match fs::read(path) {
Ok(d) => d,
Err(_) => return false,
};
if data.is_empty() {
return false;
}
let resolved_mime = match mime {
Some(m) => m.to_string(),
None => {
let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("").to_lowercase();
detect_mime(&data, &ext, clm_root)
}
};
match resolved_mime.as_str() {
"application/json" => {
serde_json::from_slice::<Value>(&data).is_ok()
}
"application/yaml" | "application/x-yaml" => {
serde_yaml::from_slice::<Value>(&data).is_ok()
}
"text/xml" | "application/xml" | "image/svg+xml" => {
let mut reader = quick_xml::Reader::from_reader(&data[..]);
reader.check_end_names(true);
let mut buf = Vec::new();
loop {
match reader.read_event_into(&mut buf) {
Ok(quick_xml::events::Event::Eof) => break,
Err(_) => return false,
_ => {}
}
buf.clear();
}
true
}
m if m.starts_with("text/") => {
!is_binary(&data)
}
other_mime => {
let safe_mime = other_mime.chars().map(|c| if c.is_alphanumeric() { c } else { '_' }).collect::<String>();
let mut manifest_file = None;
for folder in &["content", "transport", "meta"] {
let candidate = Path::new(clm_root).join("types").join(folder).join(format!("{}.yaml", safe_mime));
if candidate.exists() {
manifest_file = Some(candidate);
break;
}
}
if let Some(m_file) = manifest_file
&& let Ok(content) = fs::read_to_string(m_file)
&& let Ok(val) = serde_yaml::from_str::<Value>(&content) {
let inner = val.get("clm").unwrap_or(&val);
let magic_bytes_str = inner.get("concrete_impl")
.and_then(|v| v.get("content_type"))
.and_then(|v| v.get("detection_rules"))
.and_then(|v| v.get("magic_bytes"))
.and_then(|v| v.as_str())
.unwrap_or_default();
if !magic_bytes_str.is_empty()
&& let Some(magic_bytes) = hex_to_bytes(magic_bytes_str) {
if data.len() >= magic_bytes.len() {
return data[..magic_bytes.len()] == magic_bytes[..];
} else {
return false;
}
}
}
true
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tikz_and_tikzcd_mime_detection() {
let dummy = b"\\begin{tikzcd}\nA \\arrow[r] & B\n\\end{tikzcd}";
assert_eq!(detect_mime(dummy, "tikz", ""), "text/x-tikz");
assert_eq!(detect_mime(dummy, "tikzcd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(dummy, "tikz-cd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(dummy, ".tikz-cd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(&[], "tikz-cd", ""), "text/x-tikzcd");
assert_eq!(detect_mime(&[], "tikz", ""), "text/x-tikz");
assert_eq!(detect_mime(&[], "tikzcd", ""), "text/x-tikzcd");
}
}