PdfCraft: An open-source PDF reader and editor written by scratch in pure Rust
refactor(xfdf): split lib.rs into common, xfdf, fdf
aiongg6ab1820baee1
diff --git a/crates/xfdf/src/common.rs b/crates/xfdf/src/common.rsnew file mode 100644index 000000000..5670415d3--- /dev/null+++ b/crates/xfdf/src/common.rs@@ -0,0 +1,266 @@+use super::*;++// ── names ───────────────────────────────────────────────────────────────────────────────────++/// Form data files are attacker-supplied. Refuse a DTD and bound the node count, exactly as the+/// XFA template parser does (`crates/xfa/src/parse.rs`), and bound how deep a nested field tree+/// may go: the walk below recurses once per nesting level.+const MAX_NODES: u32 = 2_000_000;++pub(crate) const MAX_DEPTH: usize = 64;++/// The deepest element nesting accepted before the text reaches the XML parser.+///+/// roxmltree parses by recursive descent, so its stack use grows with the nesting depth: ten+/// thousand levels overflow the main thread's stack and abort the process. A stack overflow is+/// `abort()`, so `catch_unwind` cannot intercept it and the whole application dies - which is why+/// the bound has to be applied before parsing, not while walking the result. Around three thousand+/// levels still parse on the default stack, so this stays clear of the cliff while leaving far more+/// room than the walks below, which cut off at 64.+pub(crate) const MAX_XML_DEPTH: usize = 1_024;++/// Element nesting depth of `text`, skipping comments, CDATA, processing instructions, the DOCTYPE+/// and quoted attribute values. A tag that closes itself (`<field/>`) is one level while it is read+/// and does not stay open, so a long run of them cannot accumulate into the bound. It cannot+/// under-count a real element; a stray `<` in text is invalid XML and only makes it over-count,+/// which errs towards refusing the file.+pub(crate) fn xml_nesting_depth(text: &str) -> usize {+ fn find(hay: &[u8], from: usize, needle: &[u8]) -> Option<usize> {+ (from..hay.len()).find(|&p| hay[p..].starts_with(needle))+ }+ let b = text.as_bytes();+ let (mut i, mut depth, mut max) = (0usize, 0usize, 0usize);+ while i < b.len() {+ if b[i] != b'<' {+ i += 1;+ } else if b[i..].starts_with(b"<!--") {+ i = find(b, i + 4, b"-->").map_or(b.len(), |p| p + 3);+ } else if b[i..].starts_with(b"<![CDATA[") {+ i = find(b, i + 9, b"]]>").map_or(b.len(), |p| p + 3);+ } else if b[i..].starts_with(b"<?") {+ i = find(b, i + 2, b"?>").map_or(b.len(), |p| p + 2);+ } else if b[i..].starts_with(b"<!") {+ i = find(b, i + 2, b">").map_or(b.len(), |p| p + 1);+ } else if b[i..].starts_with(b"</") {+ depth = depth.saturating_sub(1);+ i = find(b, i + 2, b">").map_or(b.len(), |p| p + 1);+ } else {+ depth += 1;+ max = max.max(depth);+ // Skip the rest of the start tag, over any quoted attribute value, and remember its last+ // significant byte: a tag that ends in `/` closes itself, so it is one level deep while it+ // is read rather than a level left open.+ i += 1;+ let mut quote = 0u8;+ let mut last = 0u8;+ while i < b.len() {+ let c = b[i];+ if quote != 0 {+ if c == quote {+ quote = 0;+ }+ } else if c == b'"' || c == b'\'' {+ quote = c;+ } else if c == b'>' {+ i += 1;+ break;+ } else if !c.is_ascii_whitespace() {+ last = c;+ }+ i += 1;+ }+ if last == b'/' {+ depth -= 1;+ }+ }+ }+ max+}++pub(crate) fn check_form_xml_depth(text: &str) -> Result<(), DataError> {+ let depth = xml_nesting_depth(text);+ if depth > MAX_XML_DEPTH {+ return Err(DataError::Malformed(format!("the file nests XML elements {depth} deep, past the {MAX_XML_DEPTH} the reader accepts")));+ }+ Ok(())+}++pub(crate) fn parse_form_xml(text: &str) -> Result<roxmltree::Document<'_>, roxmltree::Error> {+ roxmltree::Document::parse_with_options(text, roxmltree::ParsingOptions { allow_dtd: false, nodes_limit: MAX_NODES })+}++pub(crate) const SUBTYPES: [(&str, &str); 17] = [+ ("Text", "text"),+ ("FreeText", "freetext"),+ ("Line", "line"),+ ("Square", "square"),+ ("Circle", "circle"),+ ("Polygon", "polygon"),+ ("PolyLine", "polyline"),+ ("Highlight", "highlight"),+ ("Underline", "underline"),+ ("Squiggly", "squiggly"),+ ("StrikeOut", "strikeout"),+ ("Stamp", "stamp"),+ ("Caret", "caret"),+ ("Ink", "ink"),+ ("FileAttachment", "fileattachment"),+ ("Sound", "sound"),+ ("Redact", "redact"),+];++pub(crate) const FLAGS: [(i64, &str); 9] = [+ (1, "invisible"),+ (2, "hidden"),+ (4, "print"),+ (8, "nozoom"),+ (16, "norotate"),+ (32, "noview"),+ (64, "readonly"),+ (128, "locked"),+ (256, "togglenoview"),+];++pub(crate) fn esc(s: &str) -> String {+ let mut o = String::with_capacity(s.len());+ for c in s.chars() {+ match c {+ '&' => o.push_str("&"),+ '<' => o.push_str("<"),+ '>' => o.push_str(">"),+ '"' => o.push_str("""),+ // XML 1.0 §3.3.3 normalizes literal attribute whitespace, but not references.+ '\t' => o.push_str("	"),+ '\n' => o.push_str(" "),+ '\r' => o.push_str(" "),+ c if (c as u32) < 0x20 && c != '\n' && c != '\t' => {}+ // XML 1.0 noncharacters are not allowed even as raw text.+ '\u{FFFE}' | '\u{FFFF}' => {}+ c => o.push(c),+ }+ }+ o+}++pub(crate) fn n(v: f64) -> String {+ let s = format!("{v:.4}");+ let s = s.trim_end_matches('0').trim_end_matches('.');+ if s == "-0" { "0".into() } else { s.into() }+}++pub(crate) fn hex(c: &[f64]) -> Option<String> {+ let rgb = match c.len() {+ 1 => [c[0]; 3],+ 3 => [c[0], c[1], c[2]],+ 4 => [(1.0 - c[0]) * (1.0 - c[3]), (1.0 - c[1]) * (1.0 - c[3]), (1.0 - c[2]) * (1.0 - c[3])],+ _ => return None,+ };+ Some(format!(+ "#{:02X}{:02X}{:02X}",+ (rgb[0].clamp(0.0, 1.0) * 255.0).round() as u8,+ (rgb[1].clamp(0.0, 1.0) * 255.0).round() as u8,+ (rgb[2].clamp(0.0, 1.0) * 255.0).round() as u8+ ))+}++pub(crate) fn parse_hex(s: &str) -> Option<[f64; 3]> {+ let h = s.trim().trim_start_matches('#');+ if h.len() != 6 || !h.bytes().all(|b| b.is_ascii_hexdigit()) {+ return None;+ }+ let p = |i: usize| h.get(i..i + 2).and_then(|s| u8::from_str_radix(s, 16).ok()).map(|v| f64::from(v) / 255.0);+ Some([p(0)?, p(2)?, p(4)?])+}++pub(crate) fn nums_of(doc: &Document, o: Option<&Object>) -> Vec<f64> {+ o.map(|o| doc.resolve(o)).and_then(|a| a.as_array().map(|a| a.iter().filter_map(|x| doc.resolve(x).as_f64()).collect())).unwrap_or_default()+}++/// A `/Rect` of exactly four finite numbers; any other entry makes the whole rectangle unusable.+pub(crate) fn rect_strict(doc: &Document, o: Option<&Object>) -> Option<[f64; 4]> {+ let num = |x: &Object| doc.resolve(x).as_f64().filter(|v| v.is_finite());+ match doc.resolve(o?).as_array()?.as_slice() {+ [x0, y0, x1, y1] => Some([num(x0)?, num(y0)?, num(x1)?, num(y1)?]),+ _ => None,+ }+}++/// Whether a quad's four corners enclose any area: some three of them are not collinear.+pub(crate) fn quad_has_area(q: &[f64; 8]) -> bool {+ let [ax, ay, bx, by, cx, cy, dx, dy] = *q;+ let cross = |(px, py): (f64, f64), (qx, qy): (f64, f64), (rx, ry): (f64, f64)| (qx - px) * (ry - py) - (qy - py) * (rx - px);+ let (a, b, c, d) = ((ax, ay), (bx, by), (cx, cy), (dx, dy));+ [cross(a, b, c), cross(a, b, d), cross(a, c, d), cross(b, c, d)].iter().any(|v| v.abs() > 0.0)+}++pub(crate) fn text_of(doc: &Document, d: &Dict, k: &[u8]) -> Option<String> {+ d.get(k).and_then(|o| match &*doc.resolve(o) {+ Object::String(s) => Some(s.to_text()),+ Object::Name(n) => Some(pdfcraft_forms::name_text(n)),+ _ => None,+ })+}++/// The numbers of a list; empty when any entry is non-finite (`nan`, `inf`), so the list is unusable as a whole.+pub(crate) fn csv(list: &str) -> Vec<f64> {+ let v: Vec<f64> = list.split([',', ';', ' ']).filter(|t| !t.is_empty()).filter_map(|t| t.trim().parse().ok()).collect();+ if v.iter().all(|x| x.is_finite()) { v } else { Vec::new() }+}++pub(crate) fn arr(v: &[f64]) -> Object {+ Object::Array(v.iter().map(|x| Object::Real(*x)).collect())+}++/// XML 1.0 fifth-edition NameStartChar, excluding `:` for an unprefixed NCName.+/// https://www.w3.org/TR/2008/REC-xml-20081126/#NT-NameStartChar+fn xml_name_start(c: char) -> bool {+ matches!(+ c,+ '_' | 'A'..='Z' | 'a'..='z'+ | '\u{C0}'..='\u{D6}' | '\u{D8}'..='\u{F6}' | '\u{F8}'..='\u{2FF}'+ | '\u{370}'..='\u{37D}' | '\u{37F}'..='\u{1FFF}'+ | '\u{200C}'..='\u{200D}' | '\u{2070}'..='\u{218F}'+ | '\u{2C00}'..='\u{2FEF}' | '\u{3001}'..='\u{D7FF}'+ | '\u{F900}'..='\u{FDCF}' | '\u{FDF0}'..='\u{FFFD}'+ | '\u{10000}'..='\u{EFFFF}'+ )+}++fn xml_name_char(c: char) -> bool {+ xml_name_start(c) || matches!(c, '-' | '.' | '0'..='9' | '\u{B7}' | '\u{300}'..='\u{36F}' | '\u{203F}'..='\u{2040}')+}++/// Keep the existing letters/digits/`_`/`-`/`.` normalization, constrained to valid NCNames.+pub(crate) fn xml_name(name: &str) -> String {+ let mut s: String =+ name.chars().map(|c| if (c.is_alphanumeric() && xml_name_char(c)) || matches!(c, '_' | '-' | '.') { c } else { '_' }).collect();+ if !s.chars().next().is_some_and(|c| (c.is_alphabetic() && xml_name_start(c)) || c == '_') {+ s.insert(0, '_');+ }+ s+}++pub(crate) fn walk_xfdf(node: roxmltree::Node, prefix: &str, out: &mut Vec<(String, Vec<String>)>, depth: usize) -> Result<(), DataError> {+ if depth > MAX_DEPTH {+ return Err(DataError::Malformed(format!("XFDF fields nest more than {MAX_DEPTH} deep")));+ }+ for f in node.children().filter(|c| c.has_tag_name("field")) {+ let Some(name) = f.attribute("name") else { continue };+ let full = if prefix.is_empty() { name.to_string() } else { format!("{prefix}.{name}") };+ let vals: Vec<String> = f+ .children()+ .filter(|c| c.has_tag_name("value"))+ // Comments and processing instructions can split a value into several text nodes.+ .map(|v| v.children().filter(|n| n.is_text()).filter_map(|n| n.text()).collect())+ .collect();+ // A leaf with no `<value>` is an empty field (the export writes one that way), so it+ // clears the field like FDF's `/V ()`; a field with kids only names their parent. A+ // leaf holding only `<value-richtext>` is not read yet, so it leaves the field alone.+ let names_kids_or_rich = f.children().any(|c| c.has_tag_name("field") || c.has_tag_name("value-richtext"));+ if !vals.is_empty() || !names_kids_or_rich {+ out.push((full.clone(), vals));+ }+ walk_xfdf(f, &full, out, depth + 1)?;+ }+ Ok(())+}diff --git a/crates/xfdf/src/fdf.rs b/crates/xfdf/src/fdf.rsnew file mode 100644index 000000000..34b59017d--- /dev/null+++ b/crates/xfdf/src/fdf.rs@@ -0,0 +1,516 @@+use super::common::{MAX_DEPTH, SUBTYPES, rect_strict, text_of};+use super::xfdf::{add_popup, apply_values, find_by_name, place};+use super::*;++fn pdf_string(s: &str) -> Vec<u8> {+ let mut v = Vec::new();+ pdfcraft_cos::serialize(&Object::String(PdfString::text(s)), &mut v);+ v+}++// Keep aliases as aliases instead of expanding a shared graph once per use. References are+// queued, not followed recursively, so cycles and long indirect chains cost linear work.+pub(crate) const MAX_FDF_OBJECTS: usize = 100_000;++pub(crate) const MAX_FDF_BYTES: usize = 64 * 1024 * 1024;++/// Direct values stay borrowed: `Document::resolve` would deep-clone them. Only+/// indirect values need an owner, and annotation bodies are never retained in discovery.+enum FdfValue<'a> {+ Borrowed(&'a Object),+ Indirect(std::sync::Arc<Object>),+}++impl<'a> FdfValue<'a> {+ fn resolve(doc: &Document, value: &'a Object) -> Self {+ match value {+ Object::Ref(_) => Self::Indirect(doc.resolve(value)),+ _ => Self::Borrowed(value),+ }+ }++ fn object(&self) -> &Object {+ match self {+ Self::Borrowed(value) => value,+ Self::Indirect(value) => value.as_ref(),+ }+ }+}++struct FdfCopy<'a> {+ doc: &'a Document,+ objects: Vec<Object>,+ numbers: HashMap<ObjRef, u32>,+ pending: Vec<(ObjRef, usize)>,+ nodes: usize,+ bytes: usize,+}++impl<'a> FdfCopy<'a> {+ fn new(doc: &'a Document) -> Self {+ Self { doc, objects: Vec::new(), numbers: HashMap::new(), pending: Vec::new(), nodes: MAX_FDF_OBJECTS, bytes: MAX_FDF_BYTES }+ }++ fn charge(&mut self, bytes: usize) -> Result<(), DataError> {+ self.bytes = self.bytes.checked_sub(bytes).ok_or(DataError::ExportLimit("64 MiB data"))?;+ Ok(())+ }++ fn slot(&mut self) -> Result<(usize, u32), DataError> {+ if self.objects.len() >= MAX_FDF_OBJECTS {+ return Err(DataError::ExportLimit("100,000 objects"));+ }+ // Object 1 is the FDF root; arena indices start at object 2. The arena is capped above.+ let index = self.objects.len();+ let number = index as u32 + 2;+ self.charge(100)?; // indirect-object and xref overhead+ self.objects.push(Object::Null);+ Ok((index, number))+ }++ fn dict(&mut self, dict: &Dict, depth: usize) -> Result<Dict, DataError> {+ if dict.len() > self.nodes {+ return Err(DataError::ExportLimit("100,000 values"));+ }+ let mut out = Dict::new();+ for (key, value) in dict.iter() {+ self.dict_entry(&mut out, key, value, depth + 1)?;+ }+ Ok(out)+ }++ fn dict_entry(&mut self, out: &mut Dict, key: &[u8], value: &Object, depth: usize) -> Result<(), DataError> {+ self.charge(key.len().saturating_mul(3).saturating_add(2))?;+ let value = self.copy(value, depth)?;+ out.set(key.to_vec(), value);+ Ok(())+ }++ /// Skip source-document links and appearances without cloning their values. The+ /// dictionary and every retained entry are charged before any owned copy is made.+ fn annotation_dict(&mut self, dict: &Dict) -> Result<Dict, DataError> {+ self.charge_value(0)?;+ let mut out = Dict::new();+ for (key, value) in dict.iter() {+ if matches!(key.as_slice(), b"P" | b"AP" | b"Popup" | b"IRT" | b"Parent" | b"FS" | b"Sound") {+ continue;+ }+ self.dict_entry(&mut out, key, value, 1)?;+ }+ Ok(out)+ }++ fn charge_value(&mut self, depth: usize) -> Result<(), DataError> {+ if depth > MAX_DEPTH {+ return Err(DataError::ExportLimit("64 direct nesting levels"));+ }+ self.nodes = self.nodes.checked_sub(1).ok_or(DataError::ExportLimit("100,000 values"))?;+ // Includes delimiters, spacing and even the longest finite f64 in plain decimal form.+ self.charge(330)?;+ Ok(())+ }++ fn is_source_page(&self, dict: &Dict) -> Result<bool, DataError> {+ let Some(value) = dict.get(b"Type") else { return Ok(false) };+ let mut value = FdfValue::Borrowed(value);+ let mut seen = HashSet::new();+ for hops in 0..=MAX_DEPTH {+ match value.object() {+ Object::Name(name) => return Ok(matches!(name.as_slice(), b"Page" | b"Pages")),+ Object::Ref(reference) => {+ if self.doc.generation(reference.num) != reference.generation || !seen.insert(*reference) {+ return Ok(false);+ }+ if hops == MAX_DEPTH {+ return Err(DataError::ExportLimit("64 Type reference levels"));+ }+ value = FdfValue::Indirect(self.doc.get(*reference));+ }+ _ => return Ok(false),+ }+ }+ Err(DataError::ExportLimit("64 Type reference levels"))+ }++ fn copy(&mut self, value: &Object, depth: usize) -> Result<Object, DataError> {+ self.charge_value(depth)?;+ Ok(match value {+ Object::Ref(source) => {+ let number = if let Some(number) = self.numbers.get(source) {+ *number+ } else {+ let (index, number) = self.slot()?;+ self.numbers.insert(*source, number);+ self.pending.push((*source, index));+ number+ };+ Object::Ref(ObjRef::new(number, 0))+ }+ Object::Array(values) => {+ if values.len() > self.nodes {+ return Err(DataError::ExportLimit("100,000 values"));+ }+ let mut out = Vec::new();+ for value in values {+ out.push(self.copy(value, depth + 1)?);+ }+ Object::Array(out)+ }+ // Source page links must not drag page contents or the page tree into an FDF.+ Object::Dict(dict) if self.is_source_page(dict)? => Object::Null,+ Object::Dict(dict) => Object::Dict(self.dict(dict, depth)?),+ Object::String(s) => {+ self.charge(s.bytes.len().saturating_mul(4))?;+ value.clone()+ }+ Object::Name(name) => {+ self.charge(name.len().saturating_mul(3))?;+ value.clone()+ }+ // A PDF stream can only be an indirect object, never a dictionary/array value.+ Object::Stream(_) => return Err(DataError::Malformed("FDF export encountered a direct stream".into())),+ other => other.clone(),+ })+ }++ fn finish(&mut self, doc: &Document) -> Result<(), DataError> {+ let mut cursor = 0;+ while let Some((source, index)) = self.pending.get(cursor).copied() {+ // ISO 32000-2 §7.3.10: an absent or stale reference denotes null. Keep reader+ // errors distinct so damaged objects cannot be silently lost during export.+ let value = if doc.generation(source.num) != source.generation {+ std::sync::Arc::new(Object::Null)+ } else {+ match doc.try_get(source.num) {+ Ok(value) => value,+ Err(pdfcraft_cos::CosError::MissingObject(_)) => std::sync::Arc::new(Object::Null),+ Err(error) => return Err(error.into()),+ }+ };+ let copied = match &*value {+ Object::Stream(stream) => {+ self.charge(stream.raw.len())?;+ Object::Stream(pdfcraft_cos::Stream { dict: self.dict(&stream.dict, 0)?, raw: stream.raw.clone() })+ }+ other => self.copy(other, 0)?,+ };+ let slot = self.objects.get_mut(index).ok_or_else(|| DataError::Malformed("FDF object slot is missing".into()))?;+ *slot = copied;+ cursor += 1;+ }+ Ok(())+ }+}++/// FDF with field values and/or comments (appearances are not carried). Each comment is an+/// indirect object of the FDF, so a reply's `/IRT` can point at its parent's object there+/// (§12.7.8.3.1). Nested values are copied and renumbered, including shared or cyclic graphs.+/// Source `/Page` and `/Pages` dictionaries become null at every copy depth.+/// Refuses exports above the object, value, direct-depth or data budget instead of losing data.+pub fn export_fdf(doc: &Document, comments: bool, fields: bool, file: &str) -> Result<Vec<u8>, DataError> {+ let mut copy = FdfCopy::new(doc);+ copy.charge(file.len().saturating_mul(8))?;+ let mut body: Vec<u8> = b"<< /FDF << ".to_vec();+ // Comment dictionaries, written after the root as objects 2, 3, …+ if fields {+ body.extend_from_slice(b"/Fields [");+ for f in pdfcraft_forms::fields(doc) {+ if matches!(f.kind, FieldKind::PushButton | FieldKind::Signature) {+ continue;+ }+ // Field dictionary, /T string and /V scalar/array, plus every emitted list+ // entry. Other field kinds emit only their first value (or a default).+ let field_nodes = if matches!(f.kind, FieldKind::List) && f.value.len() > 1 { f.value.len().saturating_add(3) } else { 3 };+ copy.nodes = copy.nodes.checked_sub(field_nodes).ok_or(DataError::ExportLimit("100,000 values"))?;+ copy.charge(f.name.len().saturating_mul(8).saturating_add(100))?;+ for value in &f.value {+ copy.charge(value.len().saturating_mul(8).saturating_add(100))?;+ }+ body.extend_from_slice(b"<< /T ");+ body.extend(pdf_string(&f.name));+ body.extend_from_slice(b" /V ");+ match f.kind {+ FieldKind::CheckBox | FieldKind::Radio => {+ let v = f.value.first().cloned().unwrap_or_else(|| "Off".into());+ pdfcraft_cos::serialize(&Object::Name(pdfcraft_forms::name_bytes(&v)), &mut body);+ }+ FieldKind::List if f.value.len() > 1 => {+ pdfcraft_cos::serialize(&Object::Array(f.value.iter().map(|v| Object::String(PdfString::text(v))).collect()), &mut body);+ }+ _ => body.extend(pdf_string(f.value.first().map(String::as_str).unwrap_or(""))),+ }+ body.extend_from_slice(b" >> ");+ }+ body.extend_from_slice(b"] ");+ }+ if comments {+ // Keep the page/array owners once. Handles retain positions, never annotation+ // bodies: the document cache can evict and reparse even a repeated source reference.+ let pages = pdfcraft_model::pages(doc);+ let mut arrays = Vec::new();+ let mut picked: Vec<(Option<ObjRef>, usize, usize)> = Vec::new();+ for (pi, page) in pages.iter().enumerate() {+ let owner = page.dict.get(b"Annots").map(|value| FdfValue::resolve(doc, value));+ let before = picked.len();+ if let Some(values) = owner.as_ref().and_then(|owner| owner.object().as_array()) {+ for (ai, a) in values.iter().enumerate() {+ let value = FdfValue::resolve(doc, a);+ let Some(d) = value.object().as_dict() else { continue };+ if d.name(b"Subtype").is_some_and(|sub| SUBTYPES.iter().any(|(s, _)| s.as_bytes() == sub)) {+ if picked.len() >= MAX_FDF_OBJECTS {+ return Err(DataError::ExportLimit("100,000 comments"));+ }+ picked.push((a.as_ref(), pi, ai));+ }+ }+ }+ // Empty/unselected arrays need no owner. Resolve subsequent pages only after+ // this page passes the cap, rather than loading them all before discovery.+ arrays.push(if picked.len() > before { owner } else { None });+ }+ let mut numbers = HashMap::new();+ for (source, _, _) in &picked {+ let (_, number) = copy.slot()?;+ if let Some(source) = source {+ numbers.insert(*source, number);+ }+ }+ copy.numbers = numbers.clone();+ let count = picked.len();+ for (index, (_, pi, ai)) in picked.into_iter().enumerate() {+ let annotation = arrays+ .get(pi)+ .and_then(Option::as_ref)+ .and_then(|owner| owner.object().as_array())+ .and_then(|values| values.get(ai))+ .ok_or_else(|| DataError::Malformed("FDF annotation slot is missing".into()))?;+ let value = FdfValue::resolve(doc, annotation);+ let d = value.object().as_dict().ok_or_else(|| DataError::Malformed("FDF comment is not a dictionary".into()))?;+ // A reply points at its parent's object in this FDF; a parent that isn't exported+ // leaves the reply unthreaded.+ let irt = d.get(b"IRT").and_then(Object::as_ref).and_then(|r| numbers.get(&r)).copied();+ let mut d = copy.annotation_dict(d)?;+ if let Some(num) = irt {+ d.set(b"IRT".to_vec(), Object::Ref(ObjRef::new(num, 0)));+ }+ d.set(b"Page".to_vec(), Object::Int(pi as i64));+ let slot = copy.objects.get_mut(index).ok_or_else(|| DataError::Malformed("FDF comment slot is missing".into()))?;+ *slot = Object::Dict(d);+ }+ body.extend_from_slice(b"/Annots [");+ for i in 0..count {+ let _ = write!(body, "{} 0 R ", i + 2);+ }+ body.extend_from_slice(b"] ");+ }+ body.extend_from_slice(b"/F ");+ body.extend(pdf_string(file));+ body.extend_from_slice(b" >> >>");+ copy.finish(doc)?;+ let mut out = b"%FDF-1.2\n%\xE2\xE3\xCF\xD3\n".to_vec();+ let mut offsets = Vec::with_capacity(copy.objects.len() + 1);+ offsets.push(out.len());+ out.extend_from_slice(b"1 0 obj\n");+ out.extend(body);+ out.extend_from_slice(b"\nendobj\n");+ for (i, object) in copy.objects.into_iter().enumerate() {+ offsets.push(out.len());+ let _ = writeln!(out, "{} 0 obj", i + 2);+ pdfcraft_cos::serialize(&object, &mut out);+ out.extend_from_slice(b"\nendobj\n");+ }+ let xref = out.len();+ let _ = write!(out, "xref\n0 {}\n0000000000 65535 f \n", offsets.len() + 1);+ for o in offsets {+ let _ = writeln!(out, "{o:010} 00000 n ");+ }+ let _ = write!(out, "trailer\n<< /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n");+ Ok(out)+}++/// What one FDF import may copy out of the file. A field tree or comment that repeats a reference+/// level after level would otherwise expand a small file into millions of values.+const MAX_FDF_IMPORT_VALUES: usize = 1_000_000;++pub(crate) struct ImportBudget {+ values: usize,+ bytes: usize,+}++impl ImportBudget {+ pub(crate) fn new() -> Self {+ Self { values: MAX_FDF_IMPORT_VALUES, bytes: MAX_FDF_BYTES }+ }++ fn spend(&mut self, values: usize, bytes: usize) -> Result<(), DataError> {+ match (self.values.checked_sub(values), self.bytes.checked_sub(bytes)) {+ (Some(v), Some(b)) => {+ (self.values, self.bytes) = (v, b);+ Ok(())+ }+ _ => Err(DataError::Malformed(format!(+ "the file expands to more than {MAX_FDF_IMPORT_VALUES} values or {} MiB of text",+ MAX_FDF_BYTES >> 20+ ))),+ }+ }+}++/// Copy an object out of another document, resolving references. A reference back to an object+/// being copied becomes null.+fn deep(src: &Document, o: &Object, depth: usize, path: &mut Vec<ObjRef>, budget: &mut ImportBudget) -> Result<Object, DataError> {+ budget.spend(1, 0)?;+ if depth > 16 {+ return Ok(Object::Null);+ }+ Ok(match o {+ Object::Ref(r) => {+ if path.contains(r) {+ return Ok(Object::Null);+ }+ path.push(*r);+ let copy = deep(src, &src.get(*r), depth + 1, path, budget);+ path.pop();+ copy?+ }+ Object::Array(a) => Object::Array(a.iter().map(|x| deep(src, x, depth + 1, path, budget)).collect::<Result<_, _>>()?),+ Object::Dict(d) => {+ Object::Dict(d.iter().map(|(k, v)| Ok((k.clone(), deep(src, v, depth + 1, path, budget)?))).collect::<Result<_, DataError>>()?)+ }+ Object::Stream(_) => Object::Null,+ Object::String(s) => {+ budget.spend(0, s.bytes.len())?;+ o.clone()+ }+ Object::Name(n) => {+ budget.spend(0, n.len())?;+ o.clone()+ }+ other => other.clone(),+ })+}++/// Read an FDF field tree. A field listed again beneath itself is skipped.+pub(crate) fn walk_fdf(+ fdf: &Document,+ list: &[Object],+ prefix: &str,+ out: &mut Vec<(String, Vec<String>)>,+ depth: usize,+ path: &mut Vec<ObjRef>,+ budget: &mut ImportBudget,+) -> Result<(), DataError> {+ if depth > 32 {+ return Ok(());+ }+ for f in list {+ budget.spend(1, 0)?;+ let held;+ let field = match f {+ Object::Ref(r) if path.contains(r) => continue,+ Object::Ref(r) => {+ held = fdf.get(*r);+ &*held+ }+ direct => direct,+ };+ let Some(d) = field.as_dict() else { continue };+ let Some(t) = d.get(b"T").and_then(|t| fdf.resolve(t).as_string().map(|s| s.to_text())) else { continue };+ let full = if prefix.is_empty() { t } else { format!("{prefix}.{t}") };+ budget.spend(0, full.len())?;+ if let Some(v) = d.get(b"V").map(|v| fdf.resolve(v)) {+ let vals: Vec<String> = match &*v {+ Object::String(s) => vec![s.to_text()],+ Object::Name(n) => vec![pdfcraft_forms::name_text(n)],+ Object::Array(a) => {+ budget.spend(a.len(), 0)?;+ a.iter().filter_map(|x| fdf.resolve(x).as_string().map(|s| s.to_text())).collect()+ }+ _ => Vec::new(),+ };+ budget.spend(vals.len(), vals.iter().map(String::len).fold(0, usize::saturating_add))?;+ out.push((full.clone(), vals));+ }+ if let Some(kids) = d.get(b"Kids").map(|k| fdf.resolve(k))+ && let Some(kids) = kids.as_array()+ {+ let entered = f.as_ref().map(|r| path.push(r)).is_some();+ let walked = walk_fdf(fdf, kids, &full, out, depth + 1, path, budget);+ if entered {+ path.pop();+ }+ walked?;+ }+ }+ Ok(())+}++pub(crate) fn fdf_body(fdf: &Document) -> Result<Dict, DataError> {+ let root = fdf.root().ok_or_else(|| DataError::Malformed("no /Root".into()))?;+ fdf.get(root)+ .as_dict()+ .and_then(|d| d.get(b"FDF").cloned())+ .map(|f| fdf.resolve(&f))+ .and_then(|f| f.as_dict().cloned())+ .ok_or(DataError::UnknownFormat)+}++pub(crate) fn import_fdf(doc: &mut Document, bytes: &[u8]) -> Result<Report, DataError> {+ let fdf = Document::open(std::sync::Arc::new(bytes.to_vec())).map_err(|e| DataError::Malformed(e.to_string()))?;+ let body = fdf_body(&fdf)?;+ let mut report = Report::default();+ let mut budget = ImportBudget::new();+ // Fields (with /Kids for hierarchical names).+ let mut values = Vec::new();+ if let Some(list) = body.get(b"Fields").map(|f| fdf.resolve(f)).and_then(|f| f.as_array().cloned()) {+ walk_fdf(&fdf, &list, "", &mut values, 0, &mut Vec::new(), &mut budget)?;+ }+ // Comments: parents first, then replies (whose /IRT needs the parent's new reference).+ let pages: Vec<ObjRef> = pdfcraft_model::pages(doc).iter().map(|p| p.obj).collect();+ let mut placed: HashMap<ObjRef, ObjRef> = HashMap::new();+ let mut later: HashMap<ObjRef, (Option<ObjRef>, Option<String>)> = HashMap::new();+ for a in body.get(b"Annots").map(|a| fdf.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {+ let Some(mut src) = fdf.resolve(&a).as_dict().cloned() else { continue };+ // The parent is another comment: link it below rather than copying it in.+ let irt = src.get(b"IRT").cloned();+ src.remove(b"IRT");+ // The pop-up is an annotation of its own (/Popup shall be an indirect reference, ISO+ // 32000-2 Table 172): copied in, it would become a direct dictionary. A new one is+ // placed on the page below, as the XFDF import does.+ let popup = src.get(b"Popup").map(|p| fdf.resolve(p)).and_then(|p| p.as_dict().cloned());+ src.remove(b"Popup");+ let mut path: Vec<ObjRef> = a.as_ref().into_iter().collect();+ let Object::Dict(mut d) = deep(&fdf, &Object::Dict(src), 0, &mut path, &mut budget)? else { continue };+ let Some(page) = d.get(b"Page").and_then(Object::as_int).and_then(|p| usize::try_from(p).ok()).and_then(|p| pages.get(p).copied()) else {+ continue;+ };+ if !d.name(b"Subtype").is_some_and(|s| SUBTYPES.iter().any(|(x, _)| x.as_bytes() == s)) {+ continue;+ }+ d.remove(b"Page");+ d.set(b"P".to_vec(), Object::Ref(page));+ let r = place(doc, page, d)?;+ later.remove(&r);+ if let Some(rect) = popup.as_ref().and_then(|p| rect_strict(&fdf, p.get(b"Rect"))) {+ let open = popup.as_ref().and_then(|p| p.get(b"Open")).is_some_and(|o| matches!(&*fdf.resolve(o), Object::Bool(true)));+ add_popup(doc, page, r, &rect, open)?;+ }+ if let Some(fr) = a.as_ref() {+ placed.insert(fr, r);+ }+ if let Some(irt) = irt {+ let parent_name = fdf.resolve(&irt).as_dict().and_then(|p| text_of(&fdf, p, b"NM"));+ later.insert(r, (irt.as_ref(), parent_name));+ }+ report.comments += 1;+ }+ for (r, (parent_obj, parent_name)) in later {+ // The parent imported from this file, else one already in the document with its name.+ let parent = parent_obj.and_then(|p| placed.get(&p).copied()).or_else(|| parent_name.and_then(|nm| find_by_name(doc, &nm)));+ if let Some(parent) = parent.filter(|p| *p != r) {+ doc.update_dict(r, |d| d.set(b"IRT".to_vec(), Object::Ref(parent)))?;+ }+ }+ apply_values(doc, &values, &mut report);+ Ok(report)+}diff --git a/crates/xfdf/src/lib.rs b/crates/xfdf/src/lib.rsindex 9c3d9ab01..1cf66ecb4 100644--- a/crates/xfdf/src/lib.rs+++ b/crates/xfdf/src/lib.rs@@ -18,6 +18,22 @@ use std::io::Write as _;use pdfcraft_cos::{Dict, Document, ObjRef, Object, PdfString};use pdfcraft_forms::{FieldKind, FieldValue};+mod fdf;+mod common;+mod xfdf;++pub use fdf::export_fdf;+use fdf::{ImportBudget, fdf_body, import_fdf, walk_fdf};+#[cfg(test)]+use fdf::{MAX_FDF_BYTES, MAX_FDF_OBJECTS};+#[cfg(test)]+use common::{MAX_DEPTH, MAX_XML_DEPTH, arr, nums_of, parse_hex, text_of, xml_nesting_depth};+use common::{check_form_xml_depth, esc, parse_form_xml, walk_xfdf, xml_name};+pub use xfdf::export_xfdf;+#[cfg(test)]+use xfdf::{LOCKED, find_by_name};+use xfdf::{apply_values, import_xfdf};+#[cfg(test)]mod tests;@@ -71,774 +87,6 @@ pub struct Report {pub rejected: Vec<String>,}-// ── names ───────────────────────────────────────────────────────────────────────────────────--/// Form data files are attacker-supplied. Refuse a DTD and bound the node count, exactly as the-/// XFA template parser does (`crates/xfa/src/parse.rs`), and bound how deep a nested field tree-/// may go: the walk below recurses once per nesting level.-const MAX_NODES: u32 = 2_000_000;-const MAX_DEPTH: usize = 64;--/// The deepest element nesting accepted before the text reaches the XML parser.-///-/// roxmltree parses by recursive descent, so its stack use grows with the nesting depth: ten-/// thousand levels overflow the main thread's stack and abort the process. A stack overflow is-/// `abort()`, so `catch_unwind` cannot intercept it and the whole application dies - which is why-/// the bound has to be applied before parsing, not while walking the result. Around three thousand-/// levels still parse on the default stack, so this stays clear of the cliff while leaving far more-/// room than the walks below, which cut off at 64.-const MAX_XML_DEPTH: usize = 1_024;--/// Element nesting depth of `text`, skipping comments, CDATA, processing instructions, the DOCTYPE-/// and quoted attribute values. A tag that closes itself (`<field/>`) is one level while it is read-/// and does not stay open, so a long run of them cannot accumulate into the bound. It cannot-/// under-count a real element; a stray `<` in text is invalid XML and only makes it over-count,-/// which errs towards refusing the file.-fn xml_nesting_depth(text: &str) -> usize {- fn find(hay: &[u8], from: usize, needle: &[u8]) -> Option<usize> {- (from..hay.len()).find(|&p| hay[p..].starts_with(needle))- }- let b = text.as_bytes();- let (mut i, mut depth, mut max) = (0usize, 0usize, 0usize);- while i < b.len() {- if b[i] != b'<' {- i += 1;- } else if b[i..].starts_with(b"<!--") {- i = find(b, i + 4, b"-->").map_or(b.len(), |p| p + 3);- } else if b[i..].starts_with(b"<![CDATA[") {- i = find(b, i + 9, b"]]>").map_or(b.len(), |p| p + 3);- } else if b[i..].starts_with(b"<?") {- i = find(b, i + 2, b"?>").map_or(b.len(), |p| p + 2);- } else if b[i..].starts_with(b"<!") {- i = find(b, i + 2, b">").map_or(b.len(), |p| p + 1);- } else if b[i..].starts_with(b"</") {- depth = depth.saturating_sub(1);- i = find(b, i + 2, b">").map_or(b.len(), |p| p + 1);- } else {- depth += 1;- max = max.max(depth);- // Skip the rest of the start tag, over any quoted attribute value, and remember its last- // significant byte: a tag that ends in `/` closes itself, so it is one level deep while it- // is read rather than a level left open.- i += 1;- let mut quote = 0u8;- let mut last = 0u8;- while i < b.len() {- let c = b[i];- if quote != 0 {- if c == quote {- quote = 0;- }- } else if c == b'"' || c == b'\'' {- quote = c;- } else if c == b'>' {- i += 1;- break;- } else if !c.is_ascii_whitespace() {- last = c;- }- i += 1;- }- if last == b'/' {- depth -= 1;- }- }- }- max-}--fn check_form_xml_depth(text: &str) -> Result<(), DataError> {- let depth = xml_nesting_depth(text);- if depth > MAX_XML_DEPTH {- return Err(DataError::Malformed(format!("the file nests XML elements {depth} deep, past the {MAX_XML_DEPTH} the reader accepts")));- }- Ok(())-}--fn parse_form_xml(text: &str) -> Result<roxmltree::Document<'_>, roxmltree::Error> {- roxmltree::Document::parse_with_options(text, roxmltree::ParsingOptions { allow_dtd: false, nodes_limit: MAX_NODES })-}--const SUBTYPES: [(&str, &str); 17] = [- ("Text", "text"),- ("FreeText", "freetext"),- ("Line", "line"),- ("Square", "square"),- ("Circle", "circle"),- ("Polygon", "polygon"),- ("PolyLine", "polyline"),- ("Highlight", "highlight"),- ("Underline", "underline"),- ("Squiggly", "squiggly"),- ("StrikeOut", "strikeout"),- ("Stamp", "stamp"),- ("Caret", "caret"),- ("Ink", "ink"),- ("FileAttachment", "fileattachment"),- ("Sound", "sound"),- ("Redact", "redact"),-];--const FLAGS: [(i64, &str); 9] = [- (1, "invisible"),- (2, "hidden"),- (4, "print"),- (8, "nozoom"),- (16, "norotate"),- (32, "noview"),- (64, "readonly"),- (128, "locked"),- (256, "togglenoview"),-];--fn esc(s: &str) -> String {- let mut o = String::with_capacity(s.len());- for c in s.chars() {- match c {- '&' => o.push_str("&"),- '<' => o.push_str("<"),- '>' => o.push_str(">"),- '"' => o.push_str("""),- // XML 1.0 §3.3.3 normalizes literal attribute whitespace, but not references.- '\t' => o.push_str("	"),- '\n' => o.push_str(" "),- '\r' => o.push_str(" "),- c if (c as u32) < 0x20 && c != '\n' && c != '\t' => {}- // XML 1.0 noncharacters are not allowed even as raw text.- '\u{FFFE}' | '\u{FFFF}' => {}- c => o.push(c),- }- }- o-}--fn n(v: f64) -> String {- let s = format!("{v:.4}");- let s = s.trim_end_matches('0').trim_end_matches('.');- if s == "-0" { "0".into() } else { s.into() }-}--fn hex(c: &[f64]) -> Option<String> {- let rgb = match c.len() {- 1 => [c[0]; 3],- 3 => [c[0], c[1], c[2]],- 4 => [(1.0 - c[0]) * (1.0 - c[3]), (1.0 - c[1]) * (1.0 - c[3]), (1.0 - c[2]) * (1.0 - c[3])],- _ => return None,- };- Some(format!(- "#{:02X}{:02X}{:02X}",- (rgb[0].clamp(0.0, 1.0) * 255.0).round() as u8,- (rgb[1].clamp(0.0, 1.0) * 255.0).round() as u8,- (rgb[2].clamp(0.0, 1.0) * 255.0).round() as u8- ))-}--fn parse_hex(s: &str) -> Option<[f64; 3]> {- let h = s.trim().trim_start_matches('#');- if h.len() != 6 || !h.bytes().all(|b| b.is_ascii_hexdigit()) {- return None;- }- let p = |i: usize| h.get(i..i + 2).and_then(|s| u8::from_str_radix(s, 16).ok()).map(|v| f64::from(v) / 255.0);- Some([p(0)?, p(2)?, p(4)?])-}--fn nums_of(doc: &Document, o: Option<&Object>) -> Vec<f64> {- o.map(|o| doc.resolve(o)).and_then(|a| a.as_array().map(|a| a.iter().filter_map(|x| doc.resolve(x).as_f64()).collect())).unwrap_or_default()-}--/// A `/Rect` of exactly four finite numbers; any other entry makes the whole rectangle unusable.-fn rect_strict(doc: &Document, o: Option<&Object>) -> Option<[f64; 4]> {- let num = |x: &Object| doc.resolve(x).as_f64().filter(|v| v.is_finite());- match doc.resolve(o?).as_array()?.as_slice() {- [x0, y0, x1, y1] => Some([num(x0)?, num(y0)?, num(x1)?, num(y1)?]),- _ => None,- }-}--/// Whether a quad's four corners enclose any area: some three of them are not collinear.-fn quad_has_area(q: &[f64; 8]) -> bool {- let [ax, ay, bx, by, cx, cy, dx, dy] = *q;- let cross = |(px, py): (f64, f64), (qx, qy): (f64, f64), (rx, ry): (f64, f64)| (qx - px) * (ry - py) - (qy - py) * (rx - px);- let (a, b, c, d) = ((ax, ay), (bx, by), (cx, cy), (dx, dy));- [cross(a, b, c), cross(a, b, d), cross(a, c, d), cross(b, c, d)].iter().any(|v| v.abs() > 0.0)-}--fn text_of(doc: &Document, d: &Dict, k: &[u8]) -> Option<String> {- d.get(k).and_then(|o| match &*doc.resolve(o) {- Object::String(s) => Some(s.to_text()),- Object::Name(n) => Some(pdfcraft_forms::name_text(n)),- _ => None,- })-}--/// The numbers of a list; empty when any entry is non-finite (`nan`, `inf`), so the list is unusable as a whole.-fn csv(list: &str) -> Vec<f64> {- let v: Vec<f64> = list.split([',', ';', ' ']).filter(|t| !t.is_empty()).filter_map(|t| t.trim().parse().ok()).collect();- if v.iter().all(|x| x.is_finite()) { v } else { Vec::new() }-}--fn arr(v: &[f64]) -> Object {- Object::Array(v.iter().map(|x| Object::Real(*x)).collect())-}--// ── export ──────────────────────────────────────────────────────────────────────────────────--/// Every comment as an XFDF element (one line per comment, replies included).-fn xfdf_annots(doc: &Document, out: &mut String) {- let pages = pdfcraft_model::pages(doc);- // NM of every annotation, for inreplyto.- let mut names: HashMap<ObjRef, String> = HashMap::new();- for p in &pages {- for a in p.dict.get(b"Annots").map(|a| doc.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {- if let Some(r) = a.as_ref()- && let Some(nm) = doc.get(r).as_dict().and_then(|d| text_of(doc, d, b"NM"))- {- names.insert(r, nm);- }- }- }- for (pi, p) in pages.iter().enumerate() {- for a in p.dict.get(b"Annots").map(|a| doc.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {- let Some(d) = doc.resolve(&a).as_dict().cloned() else { continue };- let Some(sub) = d.name(b"Subtype") else { continue };- let Some((_, tag)) = SUBTYPES.iter().find(|(s, _)| s.as_bytes() == sub) else { continue };- let mut attrs = format!(" page=\"{pi}\"");- let rect = nums_of(doc, d.get(b"Rect"));- if rect.len() == 4 {- let _ = write!(- attrs,- " rect=\"{},{},{},{}\"",- n(rect[0].min(rect[2])),- n(rect[1].min(rect[3])),- n(rect[0].max(rect[2])),- n(rect[1].max(rect[3]))- );- }- for (key, attr) in [- (&b"NM"[..], "name"),- (b"T", "title"),- (b"Subj", "subject"),- (b"M", "date"),- (b"CreationDate", "creationdate"),- (b"RT", "replyType"),- (b"State", "state"),- (b"StateModel", "statemodel"),- (b"Name", "icon"),- ] {- if let Some(v) = text_of(doc, &d, key) {- let _ = write!(attrs, " {attr}=\"{}\"", esc(&v));- }- }- let flags = d.get(b"F").and_then(|f| doc.resolve(f).as_int()).unwrap_or(0);- let fl: Vec<&str> = FLAGS.iter().filter(|(b, _)| flags & b != 0).map(|(_, s)| *s).collect();- let _ = write!(attrs, " flags=\"{}\"", fl.join(","));- if let Some(c) = hex(&nums_of(doc, d.get(b"C"))) {- let _ = write!(attrs, " color=\"{c}\"");- }- if let Some(c) = hex(&nums_of(doc, d.get(b"IC"))) {- let _ = write!(attrs, " interior-color=\"{c}\"");- }- if let Some(o) = d.get(b"CA").and_then(|o| doc.resolve(o).as_f64()) {- let _ = write!(attrs, " opacity=\"{}\"", n(o));- }- if let Some(w) = d.get(b"BS").and_then(|b| doc.resolve(b).as_dict().and_then(|b| b.get(b"W").and_then(Object::as_f64))) {- let _ = write!(attrs, " width=\"{}\"", n(w));- }- let quads = nums_of(doc, d.get(b"QuadPoints"));- if !quads.is_empty() {- let _ = write!(attrs, " coords=\"{}\"", quads.iter().map(|v| n(*v)).collect::<Vec<_>>().join(","));- }- let l = nums_of(doc, d.get(b"L"));- if l.len() == 4 {- let _ = write!(attrs, " start=\"{},{}\" end=\"{},{}\"", n(l[0]), n(l[1]), n(l[2]), n(l[3]));- }- if let Some(le) = d.get(b"LE").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned())- && le.len() == 2- {- let name = |o: &Object| o.as_name().map(|x| String::from_utf8_lossy(x).into_owned()).unwrap_or_else(|| "None".into());- let _ = write!(attrs, " head=\"{}\" tail=\"{}\"", esc(&name(&le[0])), esc(&name(&le[1])));- }- // A callout: its leader path, text-box inset, intent and (single-name) line ending.- let cl = nums_of(doc, d.get(b"CL"));- if cl.len() == 4 || cl.len() == 6 {- let _ = write!(attrs, " callout=\"{}\"", cl.iter().map(|v| n(*v)).collect::<Vec<_>>().join(","));- let rd = nums_of(doc, d.get(b"RD"));- if rd.len() == 4 {- let _ = write!(attrs, " fringe=\"{}\"", rd.iter().map(|v| n(*v)).collect::<Vec<_>>().join(","));- }- if let Some(it) = d.get(b"IT").map(|o| doc.resolve(o)).and_then(|o| o.as_name().map(|x| String::from_utf8_lossy(x).into_owned())) {- let _ = write!(attrs, " intent=\"{}\"", esc(&it));- }- if let Some(le) = d.get(b"LE").map(|o| doc.resolve(o)).and_then(|o| o.as_name().map(|x| String::from_utf8_lossy(x).into_owned())) {- let _ = write!(attrs, " head=\"{}\"", esc(&le));- }- }- if let Some(irt) = d.get(b"IRT").and_then(Object::as_ref).and_then(|r| names.get(&r)) {- let _ = write!(attrs, " inreplyto=\"{}\"", esc(irt));- }- let _ = write!(out, "<{tag}{attrs}>");- if let Some(c) = text_of(doc, &d, b"Contents") {- let _ = write!(out, "<contents>{}</contents>", esc(&c));- }- if let Some(da) = text_of(doc, &d, b"DA") {- let _ = write!(out, "<defaultappearance>{}</defaultappearance>", esc(&da));- }- let ink = d.get(b"InkList").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned()).unwrap_or_default();- if !ink.is_empty() {- out.push_str("<inklist>");- for g in ink {- let v = nums_of(doc, Some(&g));- let pts: Vec<String> = v.as_chunks::<2>().0.iter().map(|p| format!("{},{}", n(p[0]), n(p[1]))).collect();- let _ = write!(out, "<gesture>{}</gesture>", pts.join(";"));- }- out.push_str("</inklist>");- }- // Polygon and polyline points (XFDF `<vertices>`: `x,y;x,y;…`).- let vertices = nums_of(doc, d.get(b"Vertices"));- let pts: Vec<String> = vertices.as_chunks::<2>().0.iter().map(|p| format!("{},{}", n(p[0]), n(p[1]))).collect();- if !pts.is_empty() {- let _ = write!(out, "<vertices>{}</vertices>", pts.join(";"));- }- if let Some(pd) = d.get(b"Popup").map(|p| doc.resolve(p)).and_then(|p| p.as_dict().cloned()) {- let r = nums_of(doc, pd.get(b"Rect"));- if r.len() == 4 {- let open = matches!(pd.get(b"Open"), Some(Object::Bool(true)));- let _ = write!(- out,- "<popup page=\"{pi}\" rect=\"{},{},{},{}\" open=\"{}\"/>",- n(r[0]),- n(r[1]),- n(r[2]),- n(r[3]),- if open { "yes" } else { "no" }- );- }- }- let _ = writeln!(out, "</{tag}>");- }- }-}--/// Field values as nested XFDF `<field>` elements.-fn xfdf_fields(doc: &Document, out: &mut String) {- #[derive(Default)]- struct Node {- values: Vec<String>,- kids: Vec<(String, Node)>,- }- let mut root = Node::default();- for f in pdfcraft_forms::fields(doc) {- if matches!(f.kind, FieldKind::PushButton | FieldKind::Signature) {- continue;- }- let mut node = &mut root;- // One `<field>` level per part of the name, but no more levels than the import reads- // back. A `/T` can hold periods of its own, so a name can split into far more parts than- // the field tree has levels: nesting every part wrote a file the import refuses and, for- // a long enough name, recursed in `write_node` until the stack overflowed. The parts past- // the last level stay together in the deepest element's name, and the import joins them- // back with periods into the same full name.- for part in f.name.splitn(MAX_DEPTH, '.') {- let i = match node.kids.iter().position(|(k, _)| k == part) {- Some(i) => i,- None => {- node.kids.push((part.to_string(), Node::default()));- node.kids.len() - 1- }- };- node = &mut node.kids[i].1;- }- node.values = match f.kind {- FieldKind::CheckBox | FieldKind::Radio if f.value.is_empty() => vec!["Off".into()],- _ => f.value.clone(),- };- }- fn write_node(name: &str, node: &Node, out: &mut String) {- let _ = write!(out, "<field name=\"{}\">", esc(name));- for v in &node.values {- let _ = write!(out, "<value>{}</value>", esc(v));- }- for (k, kid) in &node.kids {- write_node(k, kid, out);- }- out.push_str("</field>\n");- }- for (k, kid) in &root.kids {- write_node(k, kid, out);- }-}--/// XFDF with the document's comments and/or field values.-pub fn export_xfdf(doc: &Document, comments: bool, fields: bool, file: &str) -> String {- let mut out = String::from("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<xfdf xmlns=\"http://ns.adobe.com/xfdf/\" xml:space=\"preserve\">\n");- if comments {- out.push_str("<annots>\n");- xfdf_annots(doc, &mut out);- out.push_str("</annots>\n");- }- if fields {- out.push_str("<fields>\n");- xfdf_fields(doc, &mut out);- out.push_str("</fields>\n");- }- let _ = writeln!(out, "<f href=\"{}\"/>", esc(file));- out.push_str("</xfdf>\n");- out-}--fn pdf_string(s: &str) -> Vec<u8> {- let mut v = Vec::new();- pdfcraft_cos::serialize(&Object::String(PdfString::text(s)), &mut v);- v-}--// Keep aliases as aliases instead of expanding a shared graph once per use. References are-// queued, not followed recursively, so cycles and long indirect chains cost linear work.-const MAX_FDF_OBJECTS: usize = 100_000;-const MAX_FDF_BYTES: usize = 64 * 1024 * 1024;--/// Direct values stay borrowed: `Document::resolve` would deep-clone them. Only-/// indirect values need an owner, and annotation bodies are never retained in discovery.-enum FdfValue<'a> {- Borrowed(&'a Object),- Indirect(std::sync::Arc<Object>),-}--impl<'a> FdfValue<'a> {- fn resolve(doc: &Document, value: &'a Object) -> Self {- match value {- Object::Ref(_) => Self::Indirect(doc.resolve(value)),- _ => Self::Borrowed(value),- }- }-- fn object(&self) -> &Object {- match self {- Self::Borrowed(value) => value,- Self::Indirect(value) => value.as_ref(),- }- }-}--struct FdfCopy<'a> {- doc: &'a Document,- objects: Vec<Object>,- numbers: HashMap<ObjRef, u32>,- pending: Vec<(ObjRef, usize)>,- nodes: usize,- bytes: usize,-}--impl<'a> FdfCopy<'a> {- fn new(doc: &'a Document) -> Self {- Self { doc, objects: Vec::new(), numbers: HashMap::new(), pending: Vec::new(), nodes: MAX_FDF_OBJECTS, bytes: MAX_FDF_BYTES }- }-- fn charge(&mut self, bytes: usize) -> Result<(), DataError> {- self.bytes = self.bytes.checked_sub(bytes).ok_or(DataError::ExportLimit("64 MiB data"))?;- Ok(())- }-- fn slot(&mut self) -> Result<(usize, u32), DataError> {- if self.objects.len() >= MAX_FDF_OBJECTS {- return Err(DataError::ExportLimit("100,000 objects"));- }- // Object 1 is the FDF root; arena indices start at object 2. The arena is capped above.- let index = self.objects.len();- let number = index as u32 + 2;- self.charge(100)?; // indirect-object and xref overhead- self.objects.push(Object::Null);- Ok((index, number))- }-- fn dict(&mut self, dict: &Dict, depth: usize) -> Result<Dict, DataError> {- if dict.len() > self.nodes {- return Err(DataError::ExportLimit("100,000 values"));- }- let mut out = Dict::new();- for (key, value) in dict.iter() {- self.dict_entry(&mut out, key, value, depth + 1)?;- }- Ok(out)- }-- fn dict_entry(&mut self, out: &mut Dict, key: &[u8], value: &Object, depth: usize) -> Result<(), DataError> {- self.charge(key.len().saturating_mul(3).saturating_add(2))?;- let value = self.copy(value, depth)?;- out.set(key.to_vec(), value);- Ok(())- }-- /// Skip source-document links and appearances without cloning their values. The- /// dictionary and every retained entry are charged before any owned copy is made.- fn annotation_dict(&mut self, dict: &Dict) -> Result<Dict, DataError> {- self.charge_value(0)?;- let mut out = Dict::new();- for (key, value) in dict.iter() {- if matches!(key.as_slice(), b"P" | b"AP" | b"Popup" | b"IRT" | b"Parent" | b"FS" | b"Sound") {- continue;- }- self.dict_entry(&mut out, key, value, 1)?;- }- Ok(out)- }-- fn charge_value(&mut self, depth: usize) -> Result<(), DataError> {- if depth > MAX_DEPTH {- return Err(DataError::ExportLimit("64 direct nesting levels"));- }- self.nodes = self.nodes.checked_sub(1).ok_or(DataError::ExportLimit("100,000 values"))?;- // Includes delimiters, spacing and even the longest finite f64 in plain decimal form.- self.charge(330)?;- Ok(())- }-- fn is_source_page(&self, dict: &Dict) -> Result<bool, DataError> {- let Some(value) = dict.get(b"Type") else { return Ok(false) };- let mut value = FdfValue::Borrowed(value);- let mut seen = HashSet::new();- for hops in 0..=MAX_DEPTH {- match value.object() {- Object::Name(name) => return Ok(matches!(name.as_slice(), b"Page" | b"Pages")),- Object::Ref(reference) => {- if self.doc.generation(reference.num) != reference.generation || !seen.insert(*reference) {- return Ok(false);- }- if hops == MAX_DEPTH {- return Err(DataError::ExportLimit("64 Type reference levels"));- }- value = FdfValue::Indirect(self.doc.get(*reference));- }- _ => return Ok(false),- }- }- Err(DataError::ExportLimit("64 Type reference levels"))- }-- fn copy(&mut self, value: &Object, depth: usize) -> Result<Object, DataError> {- self.charge_value(depth)?;- Ok(match value {- Object::Ref(source) => {- let number = if let Some(number) = self.numbers.get(source) {- *number- } else {- let (index, number) = self.slot()?;- self.numbers.insert(*source, number);- self.pending.push((*source, index));- number- };- Object::Ref(ObjRef::new(number, 0))- }- Object::Array(values) => {- if values.len() > self.nodes {- return Err(DataError::ExportLimit("100,000 values"));- }- let mut out = Vec::new();- for value in values {- out.push(self.copy(value, depth + 1)?);- }- Object::Array(out)- }- // Source page links must not drag page contents or the page tree into an FDF.- Object::Dict(dict) if self.is_source_page(dict)? => Object::Null,- Object::Dict(dict) => Object::Dict(self.dict(dict, depth)?),- Object::String(s) => {- self.charge(s.bytes.len().saturating_mul(4))?;- value.clone()- }- Object::Name(name) => {- self.charge(name.len().saturating_mul(3))?;- value.clone()- }- // A PDF stream can only be an indirect object, never a dictionary/array value.- Object::Stream(_) => return Err(DataError::Malformed("FDF export encountered a direct stream".into())),- other => other.clone(),- })- }-- fn finish(&mut self, doc: &Document) -> Result<(), DataError> {- let mut cursor = 0;- while let Some((source, index)) = self.pending.get(cursor).copied() {- // ISO 32000-2 §7.3.10: an absent or stale reference denotes null. Keep reader- // errors distinct so damaged objects cannot be silently lost during export.- let value = if doc.generation(source.num) != source.generation {- std::sync::Arc::new(Object::Null)- } else {- match doc.try_get(source.num) {- Ok(value) => value,- Err(pdfcraft_cos::CosError::MissingObject(_)) => std::sync::Arc::new(Object::Null),- Err(error) => return Err(error.into()),- }- };- let copied = match &*value {- Object::Stream(stream) => {- self.charge(stream.raw.len())?;- Object::Stream(pdfcraft_cos::Stream { dict: self.dict(&stream.dict, 0)?, raw: stream.raw.clone() })- }- other => self.copy(other, 0)?,- };- let slot = self.objects.get_mut(index).ok_or_else(|| DataError::Malformed("FDF object slot is missing".into()))?;- *slot = copied;- cursor += 1;- }- Ok(())- }-}--/// FDF with field values and/or comments (appearances are not carried). Each comment is an-/// indirect object of the FDF, so a reply's `/IRT` can point at its parent's object there-/// (§12.7.8.3.1). Nested values are copied and renumbered, including shared or cyclic graphs.-/// Source `/Page` and `/Pages` dictionaries become null at every copy depth.-/// Refuses exports above the object, value, direct-depth or data budget instead of losing data.-pub fn export_fdf(doc: &Document, comments: bool, fields: bool, file: &str) -> Result<Vec<u8>, DataError> {- let mut copy = FdfCopy::new(doc);- copy.charge(file.len().saturating_mul(8))?;- let mut body: Vec<u8> = b"<< /FDF << ".to_vec();- // Comment dictionaries, written after the root as objects 2, 3, …- if fields {- body.extend_from_slice(b"/Fields [");- for f in pdfcraft_forms::fields(doc) {- if matches!(f.kind, FieldKind::PushButton | FieldKind::Signature) {- continue;- }- // Field dictionary, /T string and /V scalar/array, plus every emitted list- // entry. Other field kinds emit only their first value (or a default).- let field_nodes = if matches!(f.kind, FieldKind::List) && f.value.len() > 1 { f.value.len().saturating_add(3) } else { 3 };- copy.nodes = copy.nodes.checked_sub(field_nodes).ok_or(DataError::ExportLimit("100,000 values"))?;- copy.charge(f.name.len().saturating_mul(8).saturating_add(100))?;- for value in &f.value {- copy.charge(value.len().saturating_mul(8).saturating_add(100))?;- }- body.extend_from_slice(b"<< /T ");- body.extend(pdf_string(&f.name));- body.extend_from_slice(b" /V ");- match f.kind {- FieldKind::CheckBox | FieldKind::Radio => {- let v = f.value.first().cloned().unwrap_or_else(|| "Off".into());- pdfcraft_cos::serialize(&Object::Name(pdfcraft_forms::name_bytes(&v)), &mut body);- }- FieldKind::List if f.value.len() > 1 => {- pdfcraft_cos::serialize(&Object::Array(f.value.iter().map(|v| Object::String(PdfString::text(v))).collect()), &mut body);- }- _ => body.extend(pdf_string(f.value.first().map(String::as_str).unwrap_or(""))),- }- body.extend_from_slice(b" >> ");- }- body.extend_from_slice(b"] ");- }- if comments {- // Keep the page/array owners once. Handles retain positions, never annotation- // bodies: the document cache can evict and reparse even a repeated source reference.- let pages = pdfcraft_model::pages(doc);- let mut arrays = Vec::new();- let mut picked: Vec<(Option<ObjRef>, usize, usize)> = Vec::new();- for (pi, page) in pages.iter().enumerate() {- let owner = page.dict.get(b"Annots").map(|value| FdfValue::resolve(doc, value));- let before = picked.len();- if let Some(values) = owner.as_ref().and_then(|owner| owner.object().as_array()) {- for (ai, a) in values.iter().enumerate() {- let value = FdfValue::resolve(doc, a);- let Some(d) = value.object().as_dict() else { continue };- if d.name(b"Subtype").is_some_and(|sub| SUBTYPES.iter().any(|(s, _)| s.as_bytes() == sub)) {- if picked.len() >= MAX_FDF_OBJECTS {- return Err(DataError::ExportLimit("100,000 comments"));- }- picked.push((a.as_ref(), pi, ai));- }- }- }- // Empty/unselected arrays need no owner. Resolve subsequent pages only after- // this page passes the cap, rather than loading them all before discovery.- arrays.push(if picked.len() > before { owner } else { None });- }- let mut numbers = HashMap::new();- for (source, _, _) in &picked {- let (_, number) = copy.slot()?;- if let Some(source) = source {- numbers.insert(*source, number);- }- }- copy.numbers = numbers.clone();- let count = picked.len();- for (index, (_, pi, ai)) in picked.into_iter().enumerate() {- let annotation = arrays- .get(pi)- .and_then(Option::as_ref)- .and_then(|owner| owner.object().as_array())- .and_then(|values| values.get(ai))- .ok_or_else(|| DataError::Malformed("FDF annotation slot is missing".into()))?;- let value = FdfValue::resolve(doc, annotation);- let d = value.object().as_dict().ok_or_else(|| DataError::Malformed("FDF comment is not a dictionary".into()))?;- // A reply points at its parent's object in this FDF; a parent that isn't exported- // leaves the reply unthreaded.- let irt = d.get(b"IRT").and_then(Object::as_ref).and_then(|r| numbers.get(&r)).copied();- let mut d = copy.annotation_dict(d)?;- if let Some(num) = irt {- d.set(b"IRT".to_vec(), Object::Ref(ObjRef::new(num, 0)));- }- d.set(b"Page".to_vec(), Object::Int(pi as i64));- let slot = copy.objects.get_mut(index).ok_or_else(|| DataError::Malformed("FDF comment slot is missing".into()))?;- *slot = Object::Dict(d);- }- body.extend_from_slice(b"/Annots [");- for i in 0..count {- let _ = write!(body, "{} 0 R ", i + 2);- }- body.extend_from_slice(b"] ");- }- body.extend_from_slice(b"/F ");- body.extend(pdf_string(file));- body.extend_from_slice(b" >> >>");- copy.finish(doc)?;- let mut out = b"%FDF-1.2\n%\xE2\xE3\xCF\xD3\n".to_vec();- let mut offsets = Vec::with_capacity(copy.objects.len() + 1);- offsets.push(out.len());- out.extend_from_slice(b"1 0 obj\n");- out.extend(body);- out.extend_from_slice(b"\nendobj\n");- for (i, object) in copy.objects.into_iter().enumerate() {- offsets.push(out.len());- let _ = writeln!(out, "{} 0 obj", i + 2);- pdfcraft_cos::serialize(&object, &mut out);- out.extend_from_slice(b"\nendobj\n");- }- let xref = out.len();- let _ = write!(out, "xref\n0 {}\n0000000000 65535 f \n", offsets.len() + 1);- for o in offsets {- let _ = writeln!(out, "{o:010} 00000 n ");- }- let _ = write!(out, "trailer\n<< /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n");- Ok(out)-}-/// XML 1.0 fifth-edition NameStartChar, excluding `:` for an unprefixed NCName.-/// https://www.w3.org/TR/2008/REC-xml-20081126/#NT-NameStartChar-fn xml_name_start(c: char) -> bool {- matches!(- c,- '_' | 'A'..='Z' | 'a'..='z'- | '\u{C0}'..='\u{D6}' | '\u{D8}'..='\u{F6}' | '\u{F8}'..='\u{2FF}'- | '\u{370}'..='\u{37D}' | '\u{37F}'..='\u{1FFF}'- | '\u{200C}'..='\u{200D}' | '\u{2070}'..='\u{218F}'- | '\u{2C00}'..='\u{2FEF}' | '\u{3001}'..='\u{D7FF}'- | '\u{F900}'..='\u{FDCF}' | '\u{FDF0}'..='\u{FFFD}'- | '\u{10000}'..='\u{EFFFF}'- )-}--fn xml_name_char(c: char) -> bool {- xml_name_start(c) || matches!(c, '-' | '.' | '0'..='9' | '\u{B7}' | '\u{300}'..='\u{36F}' | '\u{203F}'..='\u{2040}')-}--/// Keep the existing letters/digits/`_`/`-`/`.` normalization, constrained to valid NCNames.-fn xml_name(name: &str) -> String {- let mut s: String =- name.chars().map(|c| if (c.is_alphanumeric() && xml_name_char(c)) || matches!(c, '_' | '-' | '.') { c } else { '_' }).collect();- if !s.chars().next().is_some_and(|c| (c.is_alphabetic() && xml_name_start(c)) || c == '_') {- s.insert(0, '_');- }- s-}-/// Form data as XML, CSV or tab-delimited text (Acrobat's Export data formats).pub fn export_data(doc: &Document, format: Format) -> String {let fields: Vec<(String, String)> = pdfcraft_forms::fields(doc)@@ -882,483 +130,6 @@ pub fn export_data(doc: &Document, format: Format) -> String {}}-// ── import ──────────────────────────────────────────────────────────────────────────────────--/// Set the values of fields named in `values` (full names), counting what took.-fn apply_values(doc: &mut Document, values: &[(String, Vec<String>)], report: &mut Report) {- let all = pdfcraft_forms::fields(doc);- for (name, vals) in values {- let Some(f) = all.iter().find(|f| &f.name == name) else { continue };- let first = vals.first().cloned().unwrap_or_default();- let v = match f.kind {- FieldKind::Text => FieldValue::Text(first),- FieldKind::CheckBox => FieldValue::Check(!first.is_empty() && first != "Off"),- FieldKind::Radio => FieldValue::Radio((!first.is_empty() && first != "Off").then_some(first)),- // XML, CSV and text hold a multi-select list's values in one cell, joined by ", "- // (as export_data writes them); split it unless the whole cell is one option.- FieldKind::List if f.has(pdfcraft_forms::flags::MULTI_SELECT) && vals.len() == 1 && !f.options.iter().any(|(e, _)| *e == first) => {- FieldValue::Choice(first.split(", ").filter(|v| !v.is_empty()).map(str::to_string).collect())- }- FieldKind::Combo | FieldKind::List => FieldValue::Choice(vals.iter().filter(|v| !v.is_empty()).cloned().collect()),- FieldKind::PushButton | FieldKind::Signature => continue,- };- // Read-only fields still take imported data, as in Acrobat.- let ro = f.read_only();- if ro {- let _ = doc.update_dict(f.obj, |d| d.set(b"Ff".to_vec(), Object::Int((f.flags & !pdfcraft_forms::flags::READ_ONLY) as i64)));- }- match pdfcraft_forms::set_value(doc, name, &v) {- Ok(()) => report.fields += 1,- Err(_) => report.rejected.push(name.clone()),- }- if ro {- let _ = doc.update_dict(f.obj, |d| d.set(b"Ff".to_vec(), Object::Int(f.flags as i64)));- }- }-}--/// A new annotation dictionary from an XFDF element.-fn annot_from_xml(node: roxmltree::Node, subtype: &str, page_ref: ObjRef) -> Option<Dict> {- let mut d = Dict::new();- d.set(b"Type".to_vec(), Object::name("Annot"));- d.set(b"Subtype".to_vec(), Object::name(subtype));- d.set(b"P".to_vec(), Object::Ref(page_ref));- let rect = csv(node.attribute("rect")?);- if rect.len() != 4 {- return None;- }- d.set(b"Rect".to_vec(), arr(&rect));- for (attr, key) in [- ("name", &b"NM"[..]),- ("title", b"T"),- ("subject", b"Subj"),- ("date", b"M"),- ("creationdate", b"CreationDate"),- ("state", b"State"),- ("statemodel", b"StateModel"),- ] {- if let Some(v) = node.attribute(attr) {- d.set(key.to_vec(), PdfString::text(v));- }- }- if let Some(v) = node.attribute("replyType") {- d.set(b"RT".to_vec(), Object::name(if v.eq_ignore_ascii_case("group") { "Group" } else { "R" }));- }- if let Some(v) = node.attribute("icon") {- d.set(b"Name".to_vec(), Object::name(v));- }- let flags: i64 = node- .attribute("flags")- .unwrap_or("print")- .split(',')- .filter_map(|f| FLAGS.iter().find(|(_, s)| s.eq_ignore_ascii_case(f.trim())).map(|x| x.0))- .fold(0, |bits, flag| bits | flag);- d.set(b"F".to_vec(), Object::Int(flags));- if let Some(c) = node.attribute("color").and_then(parse_hex) {- d.set(b"C".to_vec(), arr(&c));- }- if let Some(c) = node.attribute("interior-color").and_then(parse_hex) {- d.set(b"IC".to_vec(), arr(&c));- }- if let Some(o) = node.attribute("opacity").and_then(|o| o.parse::<f64>().ok()) {- d.set(b"CA".to_vec(), Object::Real(o.clamp(0.0, 1.0)));- }- if let Some(w) = node.attribute("width").and_then(|w| w.parse::<f64>().ok()) {- let mut bs = Dict::new();- bs.set(b"W".to_vec(), Object::Real(w.max(0.0)));- bs.set(b"S".to_vec(), Object::name("S"));- d.set(b"BS".to_vec(), Object::Dict(bs));- }- if let Some(q) = node.attribute("coords") {- d.set(b"QuadPoints".to_vec(), arr(&csv(q)));- }- if let (Some(s), Some(e)) = (node.attribute("start"), node.attribute("end")) {- let (s, e) = (csv(s), csv(e));- if s.len() == 2 && e.len() == 2 {- d.set(b"L".to_vec(), arr(&[s[0], s[1], e[0], e[1]]));- }- }- if node.attribute("head").is_some() || node.attribute("tail").is_some() {- d.set(- b"LE".to_vec(),- Object::Array(vec![Object::name(node.attribute("head").unwrap_or("None")), Object::name(node.attribute("tail").unwrap_or("None"))]),- );- }- if let Some(cl) = node.attribute("callout").map(csv).filter(|c| c.len() == 4 || c.len() == 6) {- d.set(b"CL".to_vec(), arr(&cl));- if let Some(rd) = node.attribute("fringe").map(csv).filter(|r| r.len() == 4) {- d.set(b"RD".to_vec(), arr(&rd));- }- d.set(b"IT".to_vec(), Object::name(node.attribute("intent").unwrap_or("FreeTextCallout")));- // A callout's /LE is one name, not the head/tail pair of a line.- match node.attribute("head") {- Some(h) => d.set(b"LE".to_vec(), Object::name(h)),- None => {- d.remove(b"LE");- }- }- }- for child in node.children().filter(|c| c.is_element()) {- match child.tag_name().name() {- "contents" => {- d.set(b"Contents".to_vec(), PdfString::text(&child.text().unwrap_or("").replace("\r\n", "\r").replace('\n', "\r")));- }- "defaultappearance" => {- d.set(b"DA".to_vec(), PdfString::literal(child.text().unwrap_or("").as_bytes().to_vec()));- }- "inklist" => {- let list: Vec<Object> = child- .children()- .filter(|g| g.has_tag_name("gesture"))- .map(|g| arr(&g.text().unwrap_or("").split(';').flat_map(|p| csv(p).into_iter()).collect::<Vec<_>>()))- .collect();- d.set(b"InkList".to_vec(), Object::Array(list));- }- "vertices" => {- // Whole x,y pairs only; a stray trailing number is dropped.- let mut v = csv(child.text().unwrap_or(""));- v.truncate(v.len() - v.len() % 2);- if !v.is_empty() {- d.set(b"Vertices".to_vec(), arr(&v));- }- }- _ => {}- }- }- Some(d)-}--/// Put an annotation dictionary on a page, replacing one with the same `/NM`. Returns its-/// reference.-/// `/F` bits an imported file may not set on a redaction mark: Invisible, Hidden, NoView — so a-/// mark it brings in is always drawn for the user to review before content is removed.-const REDACT_UNSEEN: i64 = 1 | 2 | 32;-/// `/F` Locked (ISO 32000-2 Table 167): the user protected this annotation from change.-const LOCKED: i64 = 128;--/// An existing annotation an import must never replace, move or unlock: one the user locked, a-/// redaction mark (replacing it would drop the region the user marked to remove), or a form-/// widget or field (replacing it would set the field's value and policy around the form setter).-fn import_protected(doc: &Document, x: &Dict) -> bool {- let flags = x.get(b"F").and_then(|f| doc.resolve(f).as_int()).unwrap_or(0);- flags & LOCKED != 0 || matches!(x.name(b"Subtype"), Some(b"Redact" | b"Widget")) || x.contains(b"FT")-}--fn place(doc: &mut Document, page_ref: ObjRef, mut d: Dict) -> Result<ObjRef, DataError> {- // A redaction mark the import carries is always made visible: clear any Invisible/Hidden/NoView- // flag so it cannot remove content the user never sees.- if d.name(b"Subtype") == Some(b"Redact".as_slice()) {- let f = d.int(b"F").unwrap_or(0);- if f & REDACT_UNSEEN != 0 {- d.set(b"F".to_vec(), Object::Int(f & !REDACT_UNSEEN));- }- // Its review outline is drawn opaque, and from the area it removes: applying a mark- // without usable /QuadPoints removes its /Rect, which the outline is then drawn from.- d.remove(b"CA");- d.remove(b"ca");- let quads_drawable = d.get(b"QuadPoints").and_then(Object::as_array).is_some_and(|q| {- let v: Vec<f64> = q.iter().filter_map(Object::as_f64).filter(|v| v.is_finite()).collect();- let (quads, rest) = v.as_chunks::<8>();- v.len() == q.len() && rest.is_empty() && !quads.is_empty() && quads.iter().all(quad_has_area)- });- if !quads_drawable {- // Quads the outline can't draw, or any quad that encloses no area, are replaced by the- // /Rect's, or dropped when there is no usable /Rect either; such a mark then removes- // nothing.- match rect_strict(doc, d.get(b"Rect")) {- Some([x0, y0, x1, y1]) => {- let (l, r, b, t) = (x0.min(x1), x0.max(x1), y0.min(y1), y0.max(y1));- d.set(b"QuadPoints".to_vec(), arr(&[l, t, r, t, l, b, r, b]));- }- _ => {- d.remove(b"QuadPoints");- }- }- }- }- let nm = d.get(b"NM").and_then(|n| n.as_string().map(|s| s.to_text()));- let annots: Vec<Object> = doc- .get(page_ref)- .as_dict()- .and_then(|p| p.get(b"Annots").cloned())- .map(|a| doc.resolve(&a))- .and_then(|a| a.as_array().cloned())- .unwrap_or_default();- let mut kept = Vec::new();- let mut removed: Vec<ObjRef> = Vec::new();- // Never let a same-name import replace a protected annotation (`import_protected`): keep it,- // and add the imported dict beside it under no name of its own.- let mut clash = false;- for a in annots {- let existing = a.as_ref().and_then(|r| doc.get(r).as_dict().cloned());- let same = nm.is_some() && existing.as_ref().and_then(|x| x.get(b"NM").and_then(|n| doc.resolve(n).as_string().map(|s| s.to_text()))) == nm;- if same && existing.as_ref().is_some_and(|x| import_protected(doc, x)) {- clash = true;- kept.push(a);- } else if same {- removed.extend(a.as_ref());- } else {- kept.push(a);- }- }- if clash {- d.remove(b"NM");- }- // The replaced note's pop-up goes with it; otherwise it stays on the page pointing at a note that is no longer there.- kept.retain(|a| {- let Some(x) = a.as_ref().map(|r| doc.get(r)).and_then(|o| o.as_dict().cloned()) else { return true };- x.name(b"Subtype") != Some(b"Popup".as_slice()) || x.reference(b"Parent").is_none_or(|p| !removed.contains(&p))- });- // Keep the replaced comment's identity: replies and review statuses not included in a- // partial import still point at it through /IRT. Allocating a new object would detach- // those comments and leave their parent outside the page's annotation list.- let r = match removed.first().copied() {- Some(r) => {- doc.set(r, Object::Dict(d));- r- }- None => doc.add(Object::Dict(d)),- };- // Our own appearance where we can draw one; others keep none (viewers draw a default).- let _ = pdfcraft_annot::set_appearance(doc, r);- kept.push(Object::Ref(r));- doc.update_dict(page_ref, |p| p.set(b"Annots".to_vec(), Object::Array(kept)))?;- Ok(r)-}--/// A pop-up window for the comment `parent`, on its page.-fn add_popup(doc: &mut Document, page: ObjRef, parent: ObjRef, rect: &[f64], open: bool) -> Result<(), DataError> {- let mut p = Dict::new();- p.set(b"Type".to_vec(), Object::name("Annot"));- p.set(b"Subtype".to_vec(), Object::name("Popup"));- p.set(b"Rect".to_vec(), arr(rect));- p.set(b"Parent".to_vec(), Object::Ref(parent));- p.set(b"Open".to_vec(), Object::Bool(open));- let pr = doc.add(Object::Dict(p));- doc.update_dict(parent, |d| d.set(b"Popup".to_vec(), Object::Ref(pr)))?;- doc.update_dict(page, |pd| {- if let Some(Object::Array(a)) = pd.get_mut(b"Annots") {- a.push(Object::Ref(pr));- }- })?;- Ok(())-}--fn import_xfdf(doc: &mut Document, text: &str) -> Result<Report, DataError> {- check_form_xml_depth(text)?;- let xml = parse_form_xml(text).map_err(|e| DataError::Malformed(e.to_string()))?;- let root = xml.root_element();- if root.tag_name().name() != "xfdf" {- return Err(DataError::UnknownFormat);- }- let mut report = Report::default();- let pages: Vec<ObjRef> = pdfcraft_model::pages(doc).iter().map(|p| p.obj).collect();- // Comments: parents first, then replies (whose /IRT needs the parent's reference).- let mut by_name: HashMap<String, ObjRef> = HashMap::new();- let mut later: HashMap<ObjRef, String> = HashMap::new();- if let Some(annots) = root.children().find(|c| c.has_tag_name("annots")) {- for node in annots.children().filter(|c| c.is_element()) {- let tag = node.tag_name().name().to_ascii_lowercase();- let Some((subtype, _)) = SUBTYPES.iter().find(|(_, t)| *t == tag) else { continue };- let Some(page) = node.attribute("page").and_then(|p| p.parse::<usize>().ok()).and_then(|p| pages.get(p).copied()) else { continue };- let Some(d) = annot_from_xml(node, subtype, page) else { continue };- let r = place(doc, page, d)?;- // A later same-name record replaces this comment, including its reply relation.- later.remove(&r);- if let Some(nm) = node.attribute("name") {- by_name.insert(nm.to_string(), r);- }- if let Some(irt) = node.attribute("inreplyto") {- later.insert(r, irt.to_string());- }- // A pop-up window.- if let Some(pop) = node.children().find(|c| c.has_tag_name("popup"))- && let Some(rect) = pop.attribute("rect").map(csv).filter(|r| r.len() == 4)- {- add_popup(doc, page, r, &rect, pop.attribute("open") == Some("yes"))?;- }- report.comments += 1;- }- }- for (r, irt) in later {- if let Some(parent) = by_name.get(&irt).copied().or_else(|| find_by_name(doc, &irt)) {- doc.update_dict(r, |d| d.set(b"IRT".to_vec(), Object::Ref(parent)))?;- }- }- // Fields.- if let Some(fields) = root.children().find(|c| c.has_tag_name("fields")) {- let mut values = Vec::new();- walk_xfdf(fields, "", &mut values, 0)?;- apply_values(doc, &values, &mut report);- }- Ok(report)-}--fn find_by_name(doc: &Document, nm: &str) -> Option<ObjRef> {- for p in pdfcraft_model::pages(doc) {- for a in p.dict.get(b"Annots").map(|a| doc.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {- if let Some(r) = a.as_ref()- && doc.get(r).as_dict().and_then(|d| text_of(doc, d, b"NM")).as_deref() == Some(nm)- {- return Some(r);- }- }- }- None-}--/// What one FDF import may copy out of the file. A field tree or comment that repeats a reference-/// level after level would otherwise expand a small file into millions of values.-const MAX_FDF_IMPORT_VALUES: usize = 1_000_000;--struct ImportBudget {- values: usize,- bytes: usize,-}--impl ImportBudget {- fn new() -> Self {- Self { values: MAX_FDF_IMPORT_VALUES, bytes: MAX_FDF_BYTES }- }-- fn spend(&mut self, values: usize, bytes: usize) -> Result<(), DataError> {- match (self.values.checked_sub(values), self.bytes.checked_sub(bytes)) {- (Some(v), Some(b)) => {- (self.values, self.bytes) = (v, b);- Ok(())- }- _ => Err(DataError::Malformed(format!(- "the file expands to more than {MAX_FDF_IMPORT_VALUES} values or {} MiB of text",- MAX_FDF_BYTES >> 20- ))),- }- }-}--/// Copy an object out of another document, resolving references. A reference back to an object-/// being copied becomes null.-fn deep(src: &Document, o: &Object, depth: usize, path: &mut Vec<ObjRef>, budget: &mut ImportBudget) -> Result<Object, DataError> {- budget.spend(1, 0)?;- if depth > 16 {- return Ok(Object::Null);- }- Ok(match o {- Object::Ref(r) => {- if path.contains(r) {- return Ok(Object::Null);- }- path.push(*r);- let copy = deep(src, &src.get(*r), depth + 1, path, budget);- path.pop();- copy?- }- Object::Array(a) => Object::Array(a.iter().map(|x| deep(src, x, depth + 1, path, budget)).collect::<Result<_, _>>()?),- Object::Dict(d) => {- Object::Dict(d.iter().map(|(k, v)| Ok((k.clone(), deep(src, v, depth + 1, path, budget)?))).collect::<Result<_, DataError>>()?)- }- Object::Stream(_) => Object::Null,- Object::String(s) => {- budget.spend(0, s.bytes.len())?;- o.clone()- }- Object::Name(n) => {- budget.spend(0, n.len())?;- o.clone()- }- other => other.clone(),- })-}--fn walk_xfdf(node: roxmltree::Node, prefix: &str, out: &mut Vec<(String, Vec<String>)>, depth: usize) -> Result<(), DataError> {- if depth > MAX_DEPTH {- return Err(DataError::Malformed(format!("XFDF fields nest more than {MAX_DEPTH} deep")));- }- for f in node.children().filter(|c| c.has_tag_name("field")) {- let Some(name) = f.attribute("name") else { continue };- let full = if prefix.is_empty() { name.to_string() } else { format!("{prefix}.{name}") };- let vals: Vec<String> = f- .children()- .filter(|c| c.has_tag_name("value"))- // Comments and processing instructions can split a value into several text nodes.- .map(|v| v.children().filter(|n| n.is_text()).filter_map(|n| n.text()).collect())- .collect();- // A leaf with no `<value>` is an empty field (the export writes one that way), so it- // clears the field like FDF's `/V ()`; a field with kids only names their parent. A- // leaf holding only `<value-richtext>` is not read yet, so it leaves the field alone.- let names_kids_or_rich = f.children().any(|c| c.has_tag_name("field") || c.has_tag_name("value-richtext"));- if !vals.is_empty() || !names_kids_or_rich {- out.push((full.clone(), vals));- }- walk_xfdf(f, &full, out, depth + 1)?;- }- Ok(())-}--/// Read an FDF field tree. A field listed again beneath itself is skipped.-fn walk_fdf(- fdf: &Document,- list: &[Object],- prefix: &str,- out: &mut Vec<(String, Vec<String>)>,- depth: usize,- path: &mut Vec<ObjRef>,- budget: &mut ImportBudget,-) -> Result<(), DataError> {- if depth > 32 {- return Ok(());- }- for f in list {- budget.spend(1, 0)?;- let held;- let field = match f {- Object::Ref(r) if path.contains(r) => continue,- Object::Ref(r) => {- held = fdf.get(*r);- &*held- }- direct => direct,- };- let Some(d) = field.as_dict() else { continue };- let Some(t) = d.get(b"T").and_then(|t| fdf.resolve(t).as_string().map(|s| s.to_text())) else { continue };- let full = if prefix.is_empty() { t } else { format!("{prefix}.{t}") };- budget.spend(0, full.len())?;- if let Some(v) = d.get(b"V").map(|v| fdf.resolve(v)) {- let vals: Vec<String> = match &*v {- Object::String(s) => vec![s.to_text()],- Object::Name(n) => vec![pdfcraft_forms::name_text(n)],- Object::Array(a) => {- budget.spend(a.len(), 0)?;- a.iter().filter_map(|x| fdf.resolve(x).as_string().map(|s| s.to_text())).collect()- }- _ => Vec::new(),- };- budget.spend(vals.len(), vals.iter().map(String::len).fold(0, usize::saturating_add))?;- out.push((full.clone(), vals));- }- if let Some(kids) = d.get(b"Kids").map(|k| fdf.resolve(k))- && let Some(kids) = kids.as_array()- {- let entered = f.as_ref().map(|r| path.push(r)).is_some();- let walked = walk_fdf(fdf, kids, &full, out, depth + 1, path, budget);- if entered {- path.pop();- }- walked?;- }- }- Ok(())-}--fn fdf_body(fdf: &Document) -> Result<Dict, DataError> {- let root = fdf.root().ok_or_else(|| DataError::Malformed("no /Root".into()))?;- fdf.get(root)- .as_dict()- .and_then(|d| d.get(b"FDF").cloned())- .map(|f| fdf.resolve(&f))- .and_then(|f| f.as_dict().cloned())- .ok_or(DataError::UnknownFormat)-}-/// The field values in a form data file (FDF or XFDF) or a filled-in PDF form, in file order.pub fn data_values(bytes: &[u8]) -> Result<Vec<(String, Vec<String>)>, DataError> {if bytes.starts_with(b"%FDF") {@@ -1436,66 +207,6 @@ pub fn merge_csv(files: &[Vec<(String, Vec<String>)>]) -> String {out}-fn import_fdf(doc: &mut Document, bytes: &[u8]) -> Result<Report, DataError> {- let fdf = Document::open(std::sync::Arc::new(bytes.to_vec())).map_err(|e| DataError::Malformed(e.to_string()))?;- let body = fdf_body(&fdf)?;- let mut report = Report::default();- let mut budget = ImportBudget::new();- // Fields (with /Kids for hierarchical names).- let mut values = Vec::new();- if let Some(list) = body.get(b"Fields").map(|f| fdf.resolve(f)).and_then(|f| f.as_array().cloned()) {- walk_fdf(&fdf, &list, "", &mut values, 0, &mut Vec::new(), &mut budget)?;- }- // Comments: parents first, then replies (whose /IRT needs the parent's new reference).- let pages: Vec<ObjRef> = pdfcraft_model::pages(doc).iter().map(|p| p.obj).collect();- let mut placed: HashMap<ObjRef, ObjRef> = HashMap::new();- let mut later: HashMap<ObjRef, (Option<ObjRef>, Option<String>)> = HashMap::new();- for a in body.get(b"Annots").map(|a| fdf.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {- let Some(mut src) = fdf.resolve(&a).as_dict().cloned() else { continue };- // The parent is another comment: link it below rather than copying it in.- let irt = src.get(b"IRT").cloned();- src.remove(b"IRT");- // The pop-up is an annotation of its own (/Popup shall be an indirect reference, ISO- // 32000-2 Table 172): copied in, it would become a direct dictionary. A new one is- // placed on the page below, as the XFDF import does.- let popup = src.get(b"Popup").map(|p| fdf.resolve(p)).and_then(|p| p.as_dict().cloned());- src.remove(b"Popup");- let mut path: Vec<ObjRef> = a.as_ref().into_iter().collect();- let Object::Dict(mut d) = deep(&fdf, &Object::Dict(src), 0, &mut path, &mut budget)? else { continue };- let Some(page) = d.get(b"Page").and_then(Object::as_int).and_then(|p| usize::try_from(p).ok()).and_then(|p| pages.get(p).copied()) else {- continue;- };- if !d.name(b"Subtype").is_some_and(|s| SUBTYPES.iter().any(|(x, _)| x.as_bytes() == s)) {- continue;- }- d.remove(b"Page");- d.set(b"P".to_vec(), Object::Ref(page));- let r = place(doc, page, d)?;- later.remove(&r);- if let Some(rect) = popup.as_ref().and_then(|p| rect_strict(&fdf, p.get(b"Rect"))) {- let open = popup.as_ref().and_then(|p| p.get(b"Open")).is_some_and(|o| matches!(&*fdf.resolve(o), Object::Bool(true)));- add_popup(doc, page, r, &rect, open)?;- }- if let Some(fr) = a.as_ref() {- placed.insert(fr, r);- }- if let Some(irt) = irt {- let parent_name = fdf.resolve(&irt).as_dict().and_then(|p| text_of(&fdf, p, b"NM"));- later.insert(r, (irt.as_ref(), parent_name));- }- report.comments += 1;- }- for (r, (parent_obj, parent_name)) in later {- // The parent imported from this file, else one already in the document with its name.- let parent = parent_obj.and_then(|p| placed.get(&p).copied()).or_else(|| parent_name.and_then(|nm| find_by_name(doc, &nm)));- if let Some(parent) = parent.filter(|p| *p != r) {- doc.update_dict(r, |d| d.set(b"IRT".to_vec(), Object::Ref(parent)))?;- }- }- apply_values(doc, &values, &mut report);- Ok(report)-}-// Inspect the first logical record: tabs within quoted CSV cells are data. A quote// in the middle of an unquoted TSV name stays literal, as in the TSV reader.fn has_tab_delimiter(text: &str) -> bool {diff --git a/crates/xfdf/src/xfdf.rs b/crates/xfdf/src/xfdf.rsnew file mode 100644index 000000000..a5881adf2--- /dev/null+++ b/crates/xfdf/src/xfdf.rs@@ -0,0 +1,536 @@+use super::common::{+ FLAGS, MAX_DEPTH, SUBTYPES, arr, check_form_xml_depth, csv, esc, hex, n, nums_of, parse_form_xml, parse_hex, quad_has_area, rect_strict, text_of,+ walk_xfdf,+};+use super::*;++// ── export ──────────────────────────────────────────────────────────────────────────────────++/// Every comment as an XFDF element (one line per comment, replies included).+fn xfdf_annots(doc: &Document, out: &mut String) {+ let pages = pdfcraft_model::pages(doc);+ // NM of every annotation, for inreplyto.+ let mut names: HashMap<ObjRef, String> = HashMap::new();+ for p in &pages {+ for a in p.dict.get(b"Annots").map(|a| doc.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {+ if let Some(r) = a.as_ref()+ && let Some(nm) = doc.get(r).as_dict().and_then(|d| text_of(doc, d, b"NM"))+ {+ names.insert(r, nm);+ }+ }+ }+ for (pi, p) in pages.iter().enumerate() {+ for a in p.dict.get(b"Annots").map(|a| doc.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {+ let Some(d) = doc.resolve(&a).as_dict().cloned() else { continue };+ let Some(sub) = d.name(b"Subtype") else { continue };+ let Some((_, tag)) = SUBTYPES.iter().find(|(s, _)| s.as_bytes() == sub) else { continue };+ let mut attrs = format!(" page=\"{pi}\"");+ let rect = nums_of(doc, d.get(b"Rect"));+ if rect.len() == 4 {+ let _ = write!(+ attrs,+ " rect=\"{},{},{},{}\"",+ n(rect[0].min(rect[2])),+ n(rect[1].min(rect[3])),+ n(rect[0].max(rect[2])),+ n(rect[1].max(rect[3]))+ );+ }+ for (key, attr) in [+ (&b"NM"[..], "name"),+ (b"T", "title"),+ (b"Subj", "subject"),+ (b"M", "date"),+ (b"CreationDate", "creationdate"),+ (b"RT", "replyType"),+ (b"State", "state"),+ (b"StateModel", "statemodel"),+ (b"Name", "icon"),+ ] {+ if let Some(v) = text_of(doc, &d, key) {+ let _ = write!(attrs, " {attr}=\"{}\"", esc(&v));+ }+ }+ let flags = d.get(b"F").and_then(|f| doc.resolve(f).as_int()).unwrap_or(0);+ let fl: Vec<&str> = FLAGS.iter().filter(|(b, _)| flags & b != 0).map(|(_, s)| *s).collect();+ let _ = write!(attrs, " flags=\"{}\"", fl.join(","));+ if let Some(c) = hex(&nums_of(doc, d.get(b"C"))) {+ let _ = write!(attrs, " color=\"{c}\"");+ }+ if let Some(c) = hex(&nums_of(doc, d.get(b"IC"))) {+ let _ = write!(attrs, " interior-color=\"{c}\"");+ }+ if let Some(o) = d.get(b"CA").and_then(|o| doc.resolve(o).as_f64()) {+ let _ = write!(attrs, " opacity=\"{}\"", n(o));+ }+ if let Some(w) = d.get(b"BS").and_then(|b| doc.resolve(b).as_dict().and_then(|b| b.get(b"W").and_then(Object::as_f64))) {+ let _ = write!(attrs, " width=\"{}\"", n(w));+ }+ let quads = nums_of(doc, d.get(b"QuadPoints"));+ if !quads.is_empty() {+ let _ = write!(attrs, " coords=\"{}\"", quads.iter().map(|v| n(*v)).collect::<Vec<_>>().join(","));+ }+ let l = nums_of(doc, d.get(b"L"));+ if l.len() == 4 {+ let _ = write!(attrs, " start=\"{},{}\" end=\"{},{}\"", n(l[0]), n(l[1]), n(l[2]), n(l[3]));+ }+ if let Some(le) = d.get(b"LE").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned())+ && le.len() == 2+ {+ let name = |o: &Object| o.as_name().map(|x| String::from_utf8_lossy(x).into_owned()).unwrap_or_else(|| "None".into());+ let _ = write!(attrs, " head=\"{}\" tail=\"{}\"", esc(&name(&le[0])), esc(&name(&le[1])));+ }+ // A callout: its leader path, text-box inset, intent and (single-name) line ending.+ let cl = nums_of(doc, d.get(b"CL"));+ if cl.len() == 4 || cl.len() == 6 {+ let _ = write!(attrs, " callout=\"{}\"", cl.iter().map(|v| n(*v)).collect::<Vec<_>>().join(","));+ let rd = nums_of(doc, d.get(b"RD"));+ if rd.len() == 4 {+ let _ = write!(attrs, " fringe=\"{}\"", rd.iter().map(|v| n(*v)).collect::<Vec<_>>().join(","));+ }+ if let Some(it) = d.get(b"IT").map(|o| doc.resolve(o)).and_then(|o| o.as_name().map(|x| String::from_utf8_lossy(x).into_owned())) {+ let _ = write!(attrs, " intent=\"{}\"", esc(&it));+ }+ if let Some(le) = d.get(b"LE").map(|o| doc.resolve(o)).and_then(|o| o.as_name().map(|x| String::from_utf8_lossy(x).into_owned())) {+ let _ = write!(attrs, " head=\"{}\"", esc(&le));+ }+ }+ if let Some(irt) = d.get(b"IRT").and_then(Object::as_ref).and_then(|r| names.get(&r)) {+ let _ = write!(attrs, " inreplyto=\"{}\"", esc(irt));+ }+ let _ = write!(out, "<{tag}{attrs}>");+ if let Some(c) = text_of(doc, &d, b"Contents") {+ let _ = write!(out, "<contents>{}</contents>", esc(&c));+ }+ if let Some(da) = text_of(doc, &d, b"DA") {+ let _ = write!(out, "<defaultappearance>{}</defaultappearance>", esc(&da));+ }+ let ink = d.get(b"InkList").map(|o| doc.resolve(o)).and_then(|o| o.as_array().cloned()).unwrap_or_default();+ if !ink.is_empty() {+ out.push_str("<inklist>");+ for g in ink {+ let v = nums_of(doc, Some(&g));+ let pts: Vec<String> = v.as_chunks::<2>().0.iter().map(|p| format!("{},{}", n(p[0]), n(p[1]))).collect();+ let _ = write!(out, "<gesture>{}</gesture>", pts.join(";"));+ }+ out.push_str("</inklist>");+ }+ // Polygon and polyline points (XFDF `<vertices>`: `x,y;x,y;…`).+ let vertices = nums_of(doc, d.get(b"Vertices"));+ let pts: Vec<String> = vertices.as_chunks::<2>().0.iter().map(|p| format!("{},{}", n(p[0]), n(p[1]))).collect();+ if !pts.is_empty() {+ let _ = write!(out, "<vertices>{}</vertices>", pts.join(";"));+ }+ if let Some(pd) = d.get(b"Popup").map(|p| doc.resolve(p)).and_then(|p| p.as_dict().cloned()) {+ let r = nums_of(doc, pd.get(b"Rect"));+ if r.len() == 4 {+ let open = matches!(pd.get(b"Open"), Some(Object::Bool(true)));+ let _ = write!(+ out,+ "<popup page=\"{pi}\" rect=\"{},{},{},{}\" open=\"{}\"/>",+ n(r[0]),+ n(r[1]),+ n(r[2]),+ n(r[3]),+ if open { "yes" } else { "no" }+ );+ }+ }+ let _ = writeln!(out, "</{tag}>");+ }+ }+}++/// Field values as nested XFDF `<field>` elements.+fn xfdf_fields(doc: &Document, out: &mut String) {+ #[derive(Default)]+ struct Node {+ values: Vec<String>,+ kids: Vec<(String, Node)>,+ }+ let mut root = Node::default();+ for f in pdfcraft_forms::fields(doc) {+ if matches!(f.kind, FieldKind::PushButton | FieldKind::Signature) {+ continue;+ }+ let mut node = &mut root;+ // One `<field>` level per part of the name, but no more levels than the import reads+ // back. A `/T` can hold periods of its own, so a name can split into far more parts than+ // the field tree has levels: nesting every part wrote a file the import refuses and, for+ // a long enough name, recursed in `write_node` until the stack overflowed. The parts past+ // the last level stay together in the deepest element's name, and the import joins them+ // back with periods into the same full name.+ for part in f.name.splitn(MAX_DEPTH, '.') {+ let i = match node.kids.iter().position(|(k, _)| k == part) {+ Some(i) => i,+ None => {+ node.kids.push((part.to_string(), Node::default()));+ node.kids.len() - 1+ }+ };+ node = &mut node.kids[i].1;+ }+ node.values = match f.kind {+ FieldKind::CheckBox | FieldKind::Radio if f.value.is_empty() => vec!["Off".into()],+ _ => f.value.clone(),+ };+ }+ fn write_node(name: &str, node: &Node, out: &mut String) {+ let _ = write!(out, "<field name=\"{}\">", esc(name));+ for v in &node.values {+ let _ = write!(out, "<value>{}</value>", esc(v));+ }+ for (k, kid) in &node.kids {+ write_node(k, kid, out);+ }+ out.push_str("</field>\n");+ }+ for (k, kid) in &root.kids {+ write_node(k, kid, out);+ }+}++/// XFDF with the document's comments and/or field values.+pub fn export_xfdf(doc: &Document, comments: bool, fields: bool, file: &str) -> String {+ let mut out = String::from("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<xfdf xmlns=\"http://ns.adobe.com/xfdf/\" xml:space=\"preserve\">\n");+ if comments {+ out.push_str("<annots>\n");+ xfdf_annots(doc, &mut out);+ out.push_str("</annots>\n");+ }+ if fields {+ out.push_str("<fields>\n");+ xfdf_fields(doc, &mut out);+ out.push_str("</fields>\n");+ }+ let _ = writeln!(out, "<f href=\"{}\"/>", esc(file));+ out.push_str("</xfdf>\n");+ out+}++// ── import ──────────────────────────────────────────────────────────────────────────────────++/// Set the values of fields named in `values` (full names), counting what took.+pub(crate) fn apply_values(doc: &mut Document, values: &[(String, Vec<String>)], report: &mut Report) {+ let all = pdfcraft_forms::fields(doc);+ for (name, vals) in values {+ let Some(f) = all.iter().find(|f| &f.name == name) else { continue };+ let first = vals.first().cloned().unwrap_or_default();+ let v = match f.kind {+ FieldKind::Text => FieldValue::Text(first),+ FieldKind::CheckBox => FieldValue::Check(!first.is_empty() && first != "Off"),+ FieldKind::Radio => FieldValue::Radio((!first.is_empty() && first != "Off").then_some(first)),+ // XML, CSV and text hold a multi-select list's values in one cell, joined by ", "+ // (as export_data writes them); split it unless the whole cell is one option.+ FieldKind::List if f.has(pdfcraft_forms::flags::MULTI_SELECT) && vals.len() == 1 && !f.options.iter().any(|(e, _)| *e == first) => {+ FieldValue::Choice(first.split(", ").filter(|v| !v.is_empty()).map(str::to_string).collect())+ }+ FieldKind::Combo | FieldKind::List => FieldValue::Choice(vals.iter().filter(|v| !v.is_empty()).cloned().collect()),+ FieldKind::PushButton | FieldKind::Signature => continue,+ };+ // Read-only fields still take imported data, as in Acrobat.+ let ro = f.read_only();+ if ro {+ let _ = doc.update_dict(f.obj, |d| d.set(b"Ff".to_vec(), Object::Int((f.flags & !pdfcraft_forms::flags::READ_ONLY) as i64)));+ }+ match pdfcraft_forms::set_value(doc, name, &v) {+ Ok(()) => report.fields += 1,+ Err(_) => report.rejected.push(name.clone()),+ }+ if ro {+ let _ = doc.update_dict(f.obj, |d| d.set(b"Ff".to_vec(), Object::Int(f.flags as i64)));+ }+ }+}++/// A new annotation dictionary from an XFDF element.+fn annot_from_xml(node: roxmltree::Node, subtype: &str, page_ref: ObjRef) -> Option<Dict> {+ let mut d = Dict::new();+ d.set(b"Type".to_vec(), Object::name("Annot"));+ d.set(b"Subtype".to_vec(), Object::name(subtype));+ d.set(b"P".to_vec(), Object::Ref(page_ref));+ let rect = csv(node.attribute("rect")?);+ if rect.len() != 4 {+ return None;+ }+ d.set(b"Rect".to_vec(), arr(&rect));+ for (attr, key) in [+ ("name", &b"NM"[..]),+ ("title", b"T"),+ ("subject", b"Subj"),+ ("date", b"M"),+ ("creationdate", b"CreationDate"),+ ("state", b"State"),+ ("statemodel", b"StateModel"),+ ] {+ if let Some(v) = node.attribute(attr) {+ d.set(key.to_vec(), PdfString::text(v));+ }+ }+ if let Some(v) = node.attribute("replyType") {+ d.set(b"RT".to_vec(), Object::name(if v.eq_ignore_ascii_case("group") { "Group" } else { "R" }));+ }+ if let Some(v) = node.attribute("icon") {+ d.set(b"Name".to_vec(), Object::name(v));+ }+ let flags: i64 = node+ .attribute("flags")+ .unwrap_or("print")+ .split(',')+ .filter_map(|f| FLAGS.iter().find(|(_, s)| s.eq_ignore_ascii_case(f.trim())).map(|x| x.0))+ .fold(0, |bits, flag| bits | flag);+ d.set(b"F".to_vec(), Object::Int(flags));+ if let Some(c) = node.attribute("color").and_then(parse_hex) {+ d.set(b"C".to_vec(), arr(&c));+ }+ if let Some(c) = node.attribute("interior-color").and_then(parse_hex) {+ d.set(b"IC".to_vec(), arr(&c));+ }+ if let Some(o) = node.attribute("opacity").and_then(|o| o.parse::<f64>().ok()) {+ d.set(b"CA".to_vec(), Object::Real(o.clamp(0.0, 1.0)));+ }+ if let Some(w) = node.attribute("width").and_then(|w| w.parse::<f64>().ok()) {+ let mut bs = Dict::new();+ bs.set(b"W".to_vec(), Object::Real(w.max(0.0)));+ bs.set(b"S".to_vec(), Object::name("S"));+ d.set(b"BS".to_vec(), Object::Dict(bs));+ }+ if let Some(q) = node.attribute("coords") {+ d.set(b"QuadPoints".to_vec(), arr(&csv(q)));+ }+ if let (Some(s), Some(e)) = (node.attribute("start"), node.attribute("end")) {+ let (s, e) = (csv(s), csv(e));+ if s.len() == 2 && e.len() == 2 {+ d.set(b"L".to_vec(), arr(&[s[0], s[1], e[0], e[1]]));+ }+ }+ if node.attribute("head").is_some() || node.attribute("tail").is_some() {+ d.set(+ b"LE".to_vec(),+ Object::Array(vec![Object::name(node.attribute("head").unwrap_or("None")), Object::name(node.attribute("tail").unwrap_or("None"))]),+ );+ }+ if let Some(cl) = node.attribute("callout").map(csv).filter(|c| c.len() == 4 || c.len() == 6) {+ d.set(b"CL".to_vec(), arr(&cl));+ if let Some(rd) = node.attribute("fringe").map(csv).filter(|r| r.len() == 4) {+ d.set(b"RD".to_vec(), arr(&rd));+ }+ d.set(b"IT".to_vec(), Object::name(node.attribute("intent").unwrap_or("FreeTextCallout")));+ // A callout's /LE is one name, not the head/tail pair of a line.+ match node.attribute("head") {+ Some(h) => d.set(b"LE".to_vec(), Object::name(h)),+ None => {+ d.remove(b"LE");+ }+ }+ }+ for child in node.children().filter(|c| c.is_element()) {+ match child.tag_name().name() {+ "contents" => {+ d.set(b"Contents".to_vec(), PdfString::text(&child.text().unwrap_or("").replace("\r\n", "\r").replace('\n', "\r")));+ }+ "defaultappearance" => {+ d.set(b"DA".to_vec(), PdfString::literal(child.text().unwrap_or("").as_bytes().to_vec()));+ }+ "inklist" => {+ let list: Vec<Object> = child+ .children()+ .filter(|g| g.has_tag_name("gesture"))+ .map(|g| arr(&g.text().unwrap_or("").split(';').flat_map(|p| csv(p).into_iter()).collect::<Vec<_>>()))+ .collect();+ d.set(b"InkList".to_vec(), Object::Array(list));+ }+ "vertices" => {+ // Whole x,y pairs only; a stray trailing number is dropped.+ let mut v = csv(child.text().unwrap_or(""));+ v.truncate(v.len() - v.len() % 2);+ if !v.is_empty() {+ d.set(b"Vertices".to_vec(), arr(&v));+ }+ }+ _ => {}+ }+ }+ Some(d)+}++/// Put an annotation dictionary on a page, replacing one with the same `/NM`. Returns its+/// reference.+/// `/F` bits an imported file may not set on a redaction mark: Invisible, Hidden, NoView — so a+/// mark it brings in is always drawn for the user to review before content is removed.+const REDACT_UNSEEN: i64 = 1 | 2 | 32;++/// `/F` Locked (ISO 32000-2 Table 167): the user protected this annotation from change.+pub(crate) const LOCKED: i64 = 128;++/// An existing annotation an import must never replace, move or unlock: one the user locked, a+/// redaction mark (replacing it would drop the region the user marked to remove), or a form+/// widget or field (replacing it would set the field's value and policy around the form setter).+fn import_protected(doc: &Document, x: &Dict) -> bool {+ let flags = x.get(b"F").and_then(|f| doc.resolve(f).as_int()).unwrap_or(0);+ flags & LOCKED != 0 || matches!(x.name(b"Subtype"), Some(b"Redact" | b"Widget")) || x.contains(b"FT")+}++pub(crate) fn place(doc: &mut Document, page_ref: ObjRef, mut d: Dict) -> Result<ObjRef, DataError> {+ // A redaction mark the import carries is always made visible: clear any Invisible/Hidden/NoView+ // flag so it cannot remove content the user never sees.+ if d.name(b"Subtype") == Some(b"Redact".as_slice()) {+ let f = d.int(b"F").unwrap_or(0);+ if f & REDACT_UNSEEN != 0 {+ d.set(b"F".to_vec(), Object::Int(f & !REDACT_UNSEEN));+ }+ // Its review outline is drawn opaque, and from the area it removes: applying a mark+ // without usable /QuadPoints removes its /Rect, which the outline is then drawn from.+ d.remove(b"CA");+ d.remove(b"ca");+ let quads_drawable = d.get(b"QuadPoints").and_then(Object::as_array).is_some_and(|q| {+ let v: Vec<f64> = q.iter().filter_map(Object::as_f64).filter(|v| v.is_finite()).collect();+ let (quads, rest) = v.as_chunks::<8>();+ v.len() == q.len() && rest.is_empty() && !quads.is_empty() && quads.iter().all(quad_has_area)+ });+ if !quads_drawable {+ // Quads the outline can't draw, or any quad that encloses no area, are replaced by the+ // /Rect's, or dropped when there is no usable /Rect either; such a mark then removes+ // nothing.+ match rect_strict(doc, d.get(b"Rect")) {+ Some([x0, y0, x1, y1]) => {+ let (l, r, b, t) = (x0.min(x1), x0.max(x1), y0.min(y1), y0.max(y1));+ d.set(b"QuadPoints".to_vec(), arr(&[l, t, r, t, l, b, r, b]));+ }+ _ => {+ d.remove(b"QuadPoints");+ }+ }+ }+ }+ let nm = d.get(b"NM").and_then(|n| n.as_string().map(|s| s.to_text()));+ let annots: Vec<Object> = doc+ .get(page_ref)+ .as_dict()+ .and_then(|p| p.get(b"Annots").cloned())+ .map(|a| doc.resolve(&a))+ .and_then(|a| a.as_array().cloned())+ .unwrap_or_default();+ let mut kept = Vec::new();+ let mut removed: Vec<ObjRef> = Vec::new();+ // Never let a same-name import replace a protected annotation (`import_protected`): keep it,+ // and add the imported dict beside it under no name of its own.+ let mut clash = false;+ for a in annots {+ let existing = a.as_ref().and_then(|r| doc.get(r).as_dict().cloned());+ let same = nm.is_some() && existing.as_ref().and_then(|x| x.get(b"NM").and_then(|n| doc.resolve(n).as_string().map(|s| s.to_text()))) == nm;+ if same && existing.as_ref().is_some_and(|x| import_protected(doc, x)) {+ clash = true;+ kept.push(a);+ } else if same {+ removed.extend(a.as_ref());+ } else {+ kept.push(a);+ }+ }+ if clash {+ d.remove(b"NM");+ }+ // The replaced note's pop-up goes with it; otherwise it stays on the page pointing at a note that is no longer there.+ kept.retain(|a| {+ let Some(x) = a.as_ref().map(|r| doc.get(r)).and_then(|o| o.as_dict().cloned()) else { return true };+ x.name(b"Subtype") != Some(b"Popup".as_slice()) || x.reference(b"Parent").is_none_or(|p| !removed.contains(&p))+ });+ // Keep the replaced comment's identity: replies and review statuses not included in a+ // partial import still point at it through /IRT. Allocating a new object would detach+ // those comments and leave their parent outside the page's annotation list.+ let r = match removed.first().copied() {+ Some(r) => {+ doc.set(r, Object::Dict(d));+ r+ }+ None => doc.add(Object::Dict(d)),+ };+ // Our own appearance where we can draw one; others keep none (viewers draw a default).+ let _ = pdfcraft_annot::set_appearance(doc, r);+ kept.push(Object::Ref(r));+ doc.update_dict(page_ref, |p| p.set(b"Annots".to_vec(), Object::Array(kept)))?;+ Ok(r)+}++/// A pop-up window for the comment `parent`, on its page.+pub(crate) fn add_popup(doc: &mut Document, page: ObjRef, parent: ObjRef, rect: &[f64], open: bool) -> Result<(), DataError> {+ let mut p = Dict::new();+ p.set(b"Type".to_vec(), Object::name("Annot"));+ p.set(b"Subtype".to_vec(), Object::name("Popup"));+ p.set(b"Rect".to_vec(), arr(rect));+ p.set(b"Parent".to_vec(), Object::Ref(parent));+ p.set(b"Open".to_vec(), Object::Bool(open));+ let pr = doc.add(Object::Dict(p));+ doc.update_dict(parent, |d| d.set(b"Popup".to_vec(), Object::Ref(pr)))?;+ doc.update_dict(page, |pd| {+ if let Some(Object::Array(a)) = pd.get_mut(b"Annots") {+ a.push(Object::Ref(pr));+ }+ })?;+ Ok(())+}++pub(crate) fn import_xfdf(doc: &mut Document, text: &str) -> Result<Report, DataError> {+ check_form_xml_depth(text)?;+ let xml = parse_form_xml(text).map_err(|e| DataError::Malformed(e.to_string()))?;+ let root = xml.root_element();+ if root.tag_name().name() != "xfdf" {+ return Err(DataError::UnknownFormat);+ }+ let mut report = Report::default();+ let pages: Vec<ObjRef> = pdfcraft_model::pages(doc).iter().map(|p| p.obj).collect();+ // Comments: parents first, then replies (whose /IRT needs the parent's reference).+ let mut by_name: HashMap<String, ObjRef> = HashMap::new();+ let mut later: HashMap<ObjRef, String> = HashMap::new();+ if let Some(annots) = root.children().find(|c| c.has_tag_name("annots")) {+ for node in annots.children().filter(|c| c.is_element()) {+ let tag = node.tag_name().name().to_ascii_lowercase();+ let Some((subtype, _)) = SUBTYPES.iter().find(|(_, t)| *t == tag) else { continue };+ let Some(page) = node.attribute("page").and_then(|p| p.parse::<usize>().ok()).and_then(|p| pages.get(p).copied()) else { continue };+ let Some(d) = annot_from_xml(node, subtype, page) else { continue };+ let r = place(doc, page, d)?;+ // A later same-name record replaces this comment, including its reply relation.+ later.remove(&r);+ if let Some(nm) = node.attribute("name") {+ by_name.insert(nm.to_string(), r);+ }+ if let Some(irt) = node.attribute("inreplyto") {+ later.insert(r, irt.to_string());+ }+ // A pop-up window.+ if let Some(pop) = node.children().find(|c| c.has_tag_name("popup"))+ && let Some(rect) = pop.attribute("rect").map(csv).filter(|r| r.len() == 4)+ {+ add_popup(doc, page, r, &rect, pop.attribute("open") == Some("yes"))?;+ }+ report.comments += 1;+ }+ }+ for (r, irt) in later {+ if let Some(parent) = by_name.get(&irt).copied().or_else(|| find_by_name(doc, &irt)) {+ doc.update_dict(r, |d| d.set(b"IRT".to_vec(), Object::Ref(parent)))?;+ }+ }+ // Fields.+ if let Some(fields) = root.children().find(|c| c.has_tag_name("fields")) {+ let mut values = Vec::new();+ walk_xfdf(fields, "", &mut values, 0)?;+ apply_values(doc, &values, &mut report);+ }+ Ok(report)+}++pub(crate) fn find_by_name(doc: &Document, nm: &str) -> Option<ObjRef> {+ for p in pdfcraft_model::pages(doc) {+ for a in p.dict.get(b"Annots").map(|a| doc.resolve(a)).and_then(|a| a.as_array().cloned()).unwrap_or_default() {+ if let Some(r) = a.as_ref()+ && doc.get(r).as_dict().and_then(|d| text_of(doc, d, b"NM")).as_deref() == Some(nm)+ {+ return Some(r);+ }+ }+ }+ None+}