From 11a5711ab11c4b94acce63faa07bb42c058c124f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Fri, 20 Nov 2026 16:45:35 -0500 Subject: [PATCH] xlsx: drop unresolved/non-workbook XLSB external formulas before remapping (#4601) * xlsx: drop unresolved/non-workbook XLSB external formulas before ordinal remapping * fix(xlsb): do not treat numeric structured-table headers as external ordinals --- crates/xlsx/src/tests/xlsb_tests.rs | 43 +++-- crates/xlsx/src/xlsb.rs | 254 +++++++++++++++++----------- 2 files changed, 185 insertions(+), 112 deletions(-) diff --git a/crates/xlsx/src/tests/xlsb_tests.rs b/crates/xlsx/src/tests/xlsb_tests.rs index ca2902b25..e1e4f6afe 100644 --- a/crates/xlsx/src/tests/xlsb_tests.rs +++ b/crates/xlsx/src/tests/xlsb_tests.rs @@ -599,12 +599,12 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { s1.extend(wide("Data")); wb_records.extend(record(156, &s1)); wb_records.extend(record(144, &[])); - // Book 0 = self, Book 1 = missing ("missing"), Book 2 = valid ("ext2"). + // Book 0 = self, Book 1 = non-workbook DDE ("ext1"), Book 2 = valid workbook ("ext2"). wb_records.extend(record(357, &[])); - wb_records.extend(record(355, &wide("missing"))); + wb_records.extend(record(355, &wide("ext1"))); wb_records.extend(record(355, &wide("ext2"))); let mut xti = 2u32.to_le_bytes().to_vec(); - for (bk, first, last) in [(1u32, 0i32, 0i32), (2, 0, 0)] { + for (bk, first, last) in [(1u32, -2i32, -2i32), (2, 0, 0)] { xti.extend(bk.to_le_bytes()); xti.extend(first.to_le_bytes()); xti.extend(last.to_le_bytes()); @@ -612,6 +612,17 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { wb_records.extend(record(362, &xti)); wb_records.extend(record(132, &[])); + // DDE link part (links/dde1.bin): sbt=1 ("Excel", "topic") with item "R1C1". + let mut dde_bin = Vec::new(); + let mut dde_begin = 1u16.to_le_bytes().to_vec(); + dde_begin.extend(wide("Excel")); + dde_begin.extend(wide("topic")); + dde_bin.extend(record(360, &dde_begin)); + dde_bin.extend(record(577, &wide("R1C1"))); + dde_bin.extend(record(586, &[0u8; 7])); + dde_bin.extend(record(587, &[])); + dde_bin.extend(record(588, &[])); + let mut ext_bin = Vec::new(); let mut begin_sup = 0u16.to_le_bytes().to_vec(); begin_sup.extend(wide("rId1")); @@ -632,12 +643,7 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { data.extend(0u32.to_le_bytes()); record(9, &data) }; - let ptg_1 = { - let mut v = vec![0x3A, 0, 0]; - v.extend(0u32.to_le_bytes()); - v.extend(0u16.to_le_bytes()); - v - }; + let ptg_1 = [0x39, 0, 0, 1, 0, 0, 0]; let ptg_2 = { let mut v = vec![0x3A, 1, 0]; v.extend(0u32.to_le_bytes()); @@ -648,8 +654,8 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { data.extend(fmla_num(0, 11.0, &ptg_1)); data.extend(fmla_num(1, 22.0, &ptg_2)); - let rels = r#""#; - let types = r#""#; + let rels = r#""#; + let types = r#""#; let link_rels = r#""#; let bytes = make_zip(&[ ("[Content_Types].xml", types.as_bytes()), @@ -658,18 +664,31 @@ fn xlsb_external_link_ordinals_preserve_missing_slots_on_xlsx_save() { ("records/_rels/book.bin.rels", rels.as_bytes()), ("data/one.bin", &worksheet(&data, &[])), ("text/strings.bin", &sst()), + ("links/dde1.bin", &dde_bin), ("links/externalLink2.bin", &ext_bin), ("links/_rels/externalLink2.bin.rels", link_rels.as_bytes()), ]); let (wb, report) = read_xlsb(&bytes).unwrap(); - assert!(report.warnings.iter().any(|w| w.contains("unresolved external link")), "{:?}", report.warnings); + assert!(report.warnings.iter().any(|w| w.contains("unresolved or non-workbook external links")), "{:?}", report.warnings); + assert!(report.warnings.iter().any(|w| w.contains("replaced with their cached values")), "{:?}", report.warnings); assert!(wb.sheets[0].cell(CellRef::new(0, 0)).is_some_and(|c| c.formula.is_none() && c.value == Value::Number(11.0))); assert_eq!(wb.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("[1]SheetA!$A$1")); + // Also verify numeric structured-table headers like `SUM(Sales[2024])` are not mistaken for + // external ordinals when an omitted DDE link triggers ordinal remapping. + assert_eq!(crate::xlsb::remap_external_formula("SUM(Sales[2024])", &[None, None, Some(1)]), Ok(None)); + assert_eq!(crate::xlsb::remap_external_formula("Sales[[#Headers],[2024]]", &[None, None, Some(1)]), Ok(None)); + assert_eq!( + crate::xlsb::remap_external_formula("'[2]Other Sheet'!A1+SUM(Sales[2024])", &[None, None, Some(1)]), + Ok(Some("'[1]Other Sheet'!A1+SUM(Sales[2024])".into())) + ); + assert_eq!(crate::xlsb::remap_external_formula("[1]!'R1C1'+SUM(Sales[2024])", &[None, None, Some(1)]), Err(())); + let saved = write_xlsx(&wb).unwrap(); let (reopened, rep2) = read_xlsx(&saved).unwrap(); assert!(!rep2.warnings.iter().any(|w| w.contains("dropped")), "{:?}", rep2.warnings); + assert!(reopened.sheets[0].cell(CellRef::new(0, 0)).is_some_and(|c| c.formula.is_none() && c.value == Value::Number(11.0))); assert_eq!(reopened.sheets[0].cell(CellRef::new(0, 1)).and_then(|c| c.formula.as_ref()).map(|f| f.text.as_str()), Some("[1]SheetA!$A$1")); let saved2 = write_xlsx(&reopened).unwrap(); diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index 43853a755..9ce69909d 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -199,7 +199,7 @@ pub fn read_xlsb(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { wb.preserved = Some(Arc::new(preserved)); } if let Some(remap) = ordinal_map { - remap_workbook_external_ordinals(&mut wb, &remap); + remap_workbook_external_ordinals(&mut wb, &remap, &mut report); } for warning in package.warnings() { report.warn(warning); @@ -227,59 +227,79 @@ fn preserve_external_links( let mut refs_xml = format!(""); let mut remap = vec![None; links.len() + 1]; let mut next_ordinal = 0usize; - let mut had_missing = false; - let mut shifted = false; + let mut had_unpreserved = false; for (i, (_, link)) in links.iter().enumerate() { - let Some(link) = link else { - had_missing = true; + let Some(craft_xlsx::ExternalLink::Book(book)) = link else { + had_unpreserved = true; continue; }; + if book.target.is_none() { + had_unpreserved = true; + continue; + } next_ordinal += 1; let old_ordinal = i + 1; remap[old_ordinal] = Some(next_ordinal); - if next_ordinal != old_ordinal { - shifted = true; - } let rid = format!("rId{next_ordinal}"); let part_name = format!("xl/externalLinks/externalLink{next_ordinal}.xml"); - let (xml, rels) = external_link_part_xml(link); + let (xml, rels) = external_link_part_xml(book); p.rels.push(PreservedRel { id: rid.clone(), rel_type: format!("{NS_REL}/externalLink"), target: part_name.clone(), external: false }); p.parts.push(PreservedPart { name: part_name, content_type: CT_EXT_LINK.into(), data: xml.into_bytes().into(), rels }); let _ = write!(refs_xml, ""); } - if had_missing { - report.warn("XLSB: unresolved external link kept its cached values; its target could not be preserved"); + if had_unpreserved { + report.warn("XLSB: unresolved or non-workbook external links kept their cached values; their targets could not be preserved"); } - if next_ordinal == 0 { - return (None, None); - } - refs_xml.push_str(""); - p.elements.push(PreservedXml { slot: "externalReferences".into(), xml: refs_xml }); - (Some(p), shifted.then_some(remap)) + let preserved = if next_ordinal == 0 { + None + } else { + refs_xml.push_str(""); + p.elements.push(PreservedXml { slot: "externalReferences".into(), xml: refs_xml }); + Some(p) + }; + (preserved, had_unpreserved.then_some(remap)) } -fn remap_workbook_external_ordinals(wb: &mut Workbook, remap: &[Option]) { +fn remap_workbook_external_ordinals(wb: &mut Workbook, remap: &[Option], report: &mut ReadReport) { + let mut dropped = false; for sheet_arc in &mut wb.sheets { let sheet = Arc::make_mut(sheet_arc); let coords: Vec = sheet.cells.iter().filter(|(_, c)| c.formula.is_some()).map(|(pos, _)| pos).collect(); for pos in coords { let Some(cell) = sheet.cells.get_mut(pos) else { continue }; let Some(fm) = &cell.formula else { continue }; - if let Some(rewritten) = remap_external_formula(&fm.text, remap) { - let mut updated = (**fm).clone(); - updated.text = rewritten; - cell.formula = Some(Arc::new(updated)); + match remap_external_formula(&fm.text, remap) { + Ok(Some(rewritten)) => { + let mut updated = (**fm).clone(); + updated.text = rewritten; + cell.formula = Some(Arc::new(updated)); + } + Ok(None) => {} + Err(()) => { + cell.formula = None; + dropped = true; + } } } } - for name in &mut wb.names { - if let Some(rewritten) = remap_external_formula(&name.formula, remap) { - name.formula = rewritten; + let mut kept_names = Vec::with_capacity(wb.names.len()); + for mut name in std::mem::take(&mut wb.names) { + match remap_external_formula(&name.formula, remap) { + Ok(Some(rewritten)) => { + name.formula = rewritten; + kept_names.push(name); + } + Ok(None) => kept_names.push(name), + Err(()) => dropped = true, } } + wb.names = kept_names; + if dropped { + report.warn("XLSB: formulas referencing unresolved external links were replaced with their cached values"); + } } -fn remap_external_formula(text: &str, remap: &[Option]) -> Option { +pub(crate) fn remap_external_formula(text: &str, remap: &[Option]) -> Result, ()> { let bytes = text.as_bytes(); let mut out: Option = None; let mut i = 0; @@ -299,103 +319,137 @@ fn remap_external_formula(text: &str, remap: &[Option]) -> Option if j > i + 1 && j < bytes.len() && bytes[j] == b']' + && is_external_ordinal(text, i, j) && let Ok(old) = text[i + 1..j].parse::() - && let Some(&Some(new_n)) = remap.get(old) - && new_n != old { - let buf = out.get_or_insert_with(|| String::with_capacity(text.len())); - buf.push_str(&text[copied..=i]); - let _ = write!(buf, "{new_n}]"); - i = j + 1; - copied = i; - continue; + let Some(&Some(new_n)) = remap.get(old) else { + return Err(()); + }; + if new_n != old { + let buf = out.get_or_insert_with(|| String::with_capacity(text.len())); + buf.push_str(&text[copied..=i]); + let _ = write!(buf, "{new_n}]"); + i = j + 1; + copied = i; + continue; + } } } i += 1; } if let Some(mut buf) = out { buf.push_str(&text[copied..]); - Some(buf) + Ok(Some(buf)) } else { - None + Ok(None) } } -fn external_link_part_xml(link: &craft_xlsx::ExternalLink) -> (String, Vec) { +/// True when `[digits]` at `open..=close` is an external-book ordinal (`[1]Sheet!A1`, +/// `'[1]Other Sheet'!A1`, `[1]!Name`) rather than a numeric structured-table column (`Sales[2024]`, +/// `Sales[[#Headers],[2024]]`). +fn is_external_ordinal(text: &str, open: usize, close: usize) -> bool { + let bytes = text.as_bytes(); + let prev = open.checked_sub(1).map(|k| bytes[k]); + if let Some(b) = prev + && (b.is_ascii_alphanumeric() || matches!(b, b'_' | b'.' | b'\\' | b']' | b'[')) + { + return false; + } + let mut k = close + 1; + if prev == Some(b'\'') { + while k < bytes.len() { + if bytes[k] == b'\'' { + if bytes.get(k + 1) == Some(&b'\'') { + k += 2; + continue; + } + return bytes.get(k + 1) == Some(&b'!'); + } + k += 1; + } + return false; + } + if bytes.get(k) == Some(&b'!') { + return true; + } + let start = k; + while k < bytes.len() && (bytes[k].is_ascii_alphanumeric() || matches!(bytes[k], b'_' | b'.') || bytes[k] >= 0x80) { + k += 1; + } + k > start && bytes.get(k) == Some(&b'!') +} + +fn external_link_part_xml(book: &craft_xlsx::ExternalBook) -> (String, Vec) { let mut xml = format!("{XML_DECL}"); let mut rels = Vec::new(); - if let craft_xlsx::ExternalLink::Book(book) = link { - xml.push_str("'); + if !book.sheet_names.is_empty() { + xml.push_str(""); + for name in &book.sheet_names { + let _ = write!(xml, "", esc_attr(name)); } - xml.push('>'); - if !book.sheet_names.is_empty() { - xml.push_str(""); - for name in &book.sheet_names { - let _ = write!(xml, "", esc_attr(name)); + xml.push_str(""); + } + if !book.defined_names.is_empty() { + xml.push_str(""); + for dn in &book.defined_names { + let _ = write!(xml, ""); - } - if !book.defined_names.is_empty() { - xml.push_str(""); - for dn in &book.defined_names { - let _ = write!(xml, ""); + if let Some(sheet_id) = dn.sheet_id { + let _ = write!(xml, " sheetId=\"{sheet_id}\""); } - xml.push_str(""); + xml.push_str("/>"); } - if !book.sheet_data.is_empty() { - xml.push_str(""); - for sd in &book.sheet_data { - let _ = write!(xml, "'); - let mut rows: BTreeMap> = BTreeMap::new(); - for (pos, val) in &sd.cells { - rows.entry(pos.row).or_default().push((*pos, val)); - } - for (r, cells) in rows { - let _ = write!(xml, "", r + 1); - for (pos, val) in cells { - let r_attr = CellRef::new(pos.row, pos.col); - match val { - craft_xlsx::Value::Empty => { - let _ = write!(xml, ""); - } - craft_xlsx::Value::Number(n) => { - let _ = write!(xml, "{n}"); - } - craft_xlsx::Value::Text(t) => { - let _ = write!(xml, "{}", esc(t)); - } - craft_xlsx::Value::Bool(b) => { - let _ = write!(xml, "{}", if *b { "1" } else { "0" }); - } - craft_xlsx::Value::Error(e) => { - let _ = write!(xml, "{}", esc(map_cell_error(*e).as_str())); - } + xml.push_str(""); + } + if !book.sheet_data.is_empty() { + xml.push_str(""); + for sd in &book.sheet_data { + let _ = write!(xml, "'); + let mut rows: BTreeMap> = BTreeMap::new(); + for (pos, val) in &sd.cells { + rows.entry(pos.row).or_default().push((*pos, val)); + } + for (r, cells) in rows { + let _ = write!(xml, "", r + 1); + for (pos, val) in cells { + let r_attr = CellRef::new(pos.row, pos.col); + match val { + craft_xlsx::Value::Empty => { + let _ = write!(xml, ""); + } + craft_xlsx::Value::Number(n) => { + let _ = write!(xml, "{n}"); + } + craft_xlsx::Value::Text(t) => { + let _ = write!(xml, "{}", esc(t)); + } + craft_xlsx::Value::Bool(b) => { + let _ = write!(xml, "{}", if *b { "1" } else { "0" }); + } + craft_xlsx::Value::Error(e) => { + let _ = write!(xml, "{}", esc(map_cell_error(*e).as_str())); } } - xml.push_str(""); } - xml.push_str(""); + xml.push_str(""); } - xml.push_str(""); + xml.push_str(""); } - xml.push_str(""); - } else { - xml.push_str(""); + xml.push_str(""); } - xml.push_str(""); + xml.push_str(""); (xml, rels) }