//! Formats and the kernel half of a save (FILE-04). use std::{ io, path::{Path, PathBuf}, }; use gpui::SharedString; use quick_xml::{ events::Event, name::{Namespace, ResolveResult}, reader::NsReader, }; use crate::{Engine, Kind}; /// The lowercase extension of `path`. fn extension(path: &Path) -> String { path.extension() .and_then(|ext| ext.to_str()) .unwrap_or_default() .to_lowercase() } /// The format a save of `path` writes: its own (FILE-04). pub fn kept_format(kind: &Kind, path: &Path) -> io::Result<&'static str> { let ext = extension(path); kind.kept .iter() .find(|kept| **kept == ext) .copied() .ok_or_else(|| io::Error::new(io::ErrorKind::Unsupported, format!("cannot save .{ext}"))) } /// The format a Save As to `path` writes, or None. pub fn save_as_format(kind: &Kind, path: &Path) -> Option<&'static str> { let ext = extension(path); kind.save_as.iter().find(|format| **format == ext).copied() } /// The kernel writes `format` into `work`; the bytes come back. pub fn kernel_bytes( worker: &mut G::Worker, doc: &G::Doc, work: &Path, format: &str, ) -> io::Result> { let copy = work.join(format!("save.{format}")); G::write(worker, doc, ©, format)?; let bytes = std::fs::read(©)?; log::info!("office: the kernel wrote {} bytes of {format}", bytes.len()); Ok(bytes) } /// Whether `path` carries macros Ely will not round-trip (LOK-11). pub fn macro_risk(kind: &Kind, path: &Path) -> io::Result { let Some(macros) = kind.macros else { return Ok(false); }; if macros.contains(&extension(path).as_str()) { return Ok(true); } let bytes = std::fs::read(path)?; if bytes.starts_with(b"PK\x03\x04") { let names = zip_names(&bytes)?; return Ok(names .iter() .any(|name| name.ends_with("vbaProject.bin") || name.starts_with("Basic/"))); } if bytes.starts_with(&[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]) { return Ok(ole_has_vba(&bytes)); } flat_odf_has_basic(&bytes) } /// The office namespace that carries Basic libraries. const OOO: &[u8] = b"http://openoffice.org/2004/office"; /// Whether flat ODF embeds a Basic library, namespaces in scope. fn flat_odf_has_basic(bytes: &[u8]) -> io::Result { let text = bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes); if !text.trim_ascii_start().starts_with(b"<") { return Ok(false); } let mut reader = NsReader::from_reader(text); let mut buf = Vec::new(); loop { let (bound, event) = reader .read_resolved_event_into(&mut buf) .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?; match (bound, event) { (ResolveResult::Bound(Namespace(OOO)), Event::Start(tag) | Event::Empty(tag)) if tag.local_name().as_ref() == b"library-embedded" => { return Ok(true); } (_, Event::Eof) => return Ok(false), _ => {} } buf.clear(); } } /// The entry names in a zip's central directory. fn zip_names(bytes: &[u8]) -> io::Result> { let bad = || io::Error::new(io::ErrorKind::InvalidData, "a damaged zip directory"); let u16_at = |at: usize| { bytes .get(at..at + 2) .map(|b| u16::from_le_bytes([b[0], b[1]]) as usize) }; let u32_at = |at: usize| { bytes .get(at..at + 4) .map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]]) as usize) }; let end = (0..bytes.len().saturating_sub(21)) .rev() .find(|&at| bytes[at..].starts_with(b"PK\x05\x06")) .ok_or_else(bad)?; let (count, mut at) = ( u16_at(end + 10).ok_or_else(bad)?, u32_at(end + 16).ok_or_else(bad)?, ); let mut names = Vec::with_capacity(count); for _ in 0..count { if !bytes .get(at..) .is_some_and(|rest| rest.starts_with(b"PK\x01\x02")) { return Err(bad()); } let name_len = u16_at(at + 28).ok_or_else(bad)?; let skip = u16_at(at + 30).ok_or_else(bad)? + u16_at(at + 32).ok_or_else(bad)?; let name = bytes.get(at + 46..at + 46 + name_len).ok_or_else(bad)?; names.push(String::from_utf8_lossy(name).into_owned()); at += 46 + name_len + skip; } Ok(names) } /// Whether an OLE file has a `_VBA_PROJECT` directory entry. fn ole_has_vba(bytes: &[u8]) -> bool { let name: Vec = "_VBA_PROJECT" .encode_utf16() .flat_map(u16::to_le_bytes) .collect(); // 128-byte entries: name, byte length, type 2. (512..bytes.len().saturating_sub(128)) .step_by(128) .any(|at| { let entry = &bytes[at..at + 128]; entry.starts_with(&name) && u16::from_le_bytes([entry[64], entry[65]]) as usize == name.len() + 2 && entry[66] == 2 }) } /// A path's file name for tab titles. pub fn file_name(path: &Path) -> SharedString { path.file_name() .map(|name| name.to_string_lossy().into_owned()) .unwrap_or_default() .into() } /// A fresh scratch folder for one document's kernel copies. pub fn work_dir(root: &Path, id: u64) -> io::Result { let dir = root.join(format!("doc-{id}")); if dir.try_exists()? { std::fs::remove_dir_all(&dir)?; } std::fs::create_dir_all(&dir)?; Ok(dir) } #[cfg(test)] mod tests { use super::*; const KIND: Kind = Kind { app: ely_platform::AppId::Doc, kept: &["docx", "odt", "doc"], save_as: &["docx", "odt"], macros: Some(&["docm", "dotm"]), }; #[test] fn saves_keep_the_format_and_save_as_converts() { let kept = |path: &str| kept_format(&KIND, Path::new(path)); assert_eq!(kept("/a/Contract.DOC").expect("doc"), "doc"); assert_eq!(kept("/a/b.odt").expect("odt"), "odt"); assert!(kept("/a/b.pages").is_err(), "unknown formats fail"); assert_eq!(save_as_format(&KIND, Path::new("/a/b.docx")), Some("docx")); assert_eq!(save_as_format(&KIND, Path::new("/a/b.pdf")), None); } #[test] fn macros_are_found_by_structure_never_by_text() { let dir = std::env::temp_dir().join(format!("ely-office-risk-{}", std::process::id())); std::fs::create_dir_all(&dir).expect("a dir"); let write = |name: &str, body: &[u8]| { let path = dir.join(name); std::fs::write(&path, body).expect("writes"); path }; assert!(macro_risk(&KIND, &write("a.docm", b"PK")).expect("docm")); let notes = write( "notes.txt", b"The archive path is Basic/Standard/Module1.xml and vbaProject.bin", ); assert!( !macro_risk(&KIND, ¬es).expect("text"), "words in text are not macros" ); let example = write( "xml-example.txt", b"Example: ", ); assert!( !macro_risk(&KIND, &example).expect("text with a tag"), "unbound tags are text" ); let root = |prefix: &str| { format!( "" ) }; let basic = format!( "{}", root("ooo") ); assert!(macro_risk(&KIND, &write("f.fodt", basic.as_bytes())).expect("flat basic")); let alias = format!( "{}", root("basic") ); assert!( macro_risk(&KIND, &write("g.fodt", alias.as_bytes())).expect("aliased"), "any bound prefix counts" ); let nested = format!( "{}", root("ooo") ); assert!( macro_risk(&KIND, &write("n.fods", nested.as_bytes())).expect("nested"), "a child may declare the namespace" ); let shadowed = format!( "{}", root("ooo") ); assert!( !macro_risk(&KIND, &write("s.fodt", shadowed.as_bytes())).expect("shadowed"), "a prefix rebound elsewhere is not Basic" ); assert!( macro_risk(&KIND, &write("bad.fodt", b"")).is_err(), "broken XML is an error" ); std::fs::remove_dir_all(&dir).expect("cleans"); } }