use std::collections::{BTreeMap, BTreeSet};
use cadkit_core::{Document, Entity, EntityKind, Error, Model, ReadOptions, Result, Warning};
use super::encode::{f64_at, put, string_link, u32_at, u64_at};
use super::{V8Seed, WriteOptions, compressed, container, named, oleps, tables::NamedRecord};
use crate::le;
use crate::native::decode_v8;
use crate::native::element::ElementData;
use crate::native::linkage::{self, LinkageData};
use crate::native::v8::{Page, RawElement, V8Model};
const MODEL_INDEX_MAGIC: u32 = 0xaa00_ba11;
const MODEL_INDEX_ENTRY: usize = 32;
const MAX_MODEL_NAME_UNITS: usize = 249;
const MODEL_TIME: usize = 0x88;
const ELEMENT_TIME: usize = 0x18;
const HIGH_WATER_ID: usize = 0x128;
const FILE_TIME: usize = 0x130;
const MAX_TIMESTAMP_MS: f64 = 1e15;
const SHARED_CELL_DEFINITION: u16 = 34;
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
#[non_exhaustive]
pub struct StripSeedOptions {
pub keep_controls: bool,
pub keep_raster_template: bool,
pub keep_cell_definitions: bool,
pub model_name: Option<String>,
pub timestamp_ms: f64,
pub application: String,
}
impl Default for StripSeedOptions {
fn default() -> Self {
Self {
keep_controls: false,
keep_raster_template: false,
keep_cell_definitions: true,
model_name: None,
timestamp_ms: 0.0,
application: "cadkit".into(),
}
}
}
impl StripSeedOptions {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn with_keep_controls(mut self, keep: bool) -> Self {
self.keep_controls = keep;
self
}
#[must_use]
pub fn with_keep_raster_template(mut self, keep: bool) -> Self {
self.keep_raster_template = keep;
self
}
#[must_use]
pub fn with_keep_cell_definitions(mut self, keep: bool) -> Self {
self.keep_cell_definitions = keep;
self
}
#[must_use]
pub fn with_model_name(mut self, name: Option<impl Into<String>>) -> Self {
self.model_name = name.map(Into::into);
self
}
#[must_use]
pub fn with_timestamp_ms(mut self, timestamp_ms: f64) -> Self {
self.timestamp_ms = timestamp_ms;
self
}
#[must_use]
pub fn with_application(mut self, application: impl Into<String>) -> Self {
self.application = application.into();
self
}
fn validate(&self) -> Result<()> {
if !self.timestamp_ms.is_finite()
|| self.timestamp_ms < 0.0
|| self.timestamp_ms > MAX_TIMESTAMP_MS
{
return Err(Error::invalid(
0,
"DGN seed timestamp must lie between 0 and 1e15 ms",
));
}
if let Some(name) = &self.model_name {
let units = name.encode_utf16().count();
if units == 0 || units > MAX_MODEL_NAME_UNITS || name.contains('\0') {
return Err(Error::invalid(
0,
"DGN model name must hold 1 to 249 UTF-16 units and no NUL",
));
}
}
if self.application.encode_utf16().count() > oleps::MAX_APPLICATION_UNITS
|| self.application.contains('\0')
{
return Err(Error::invalid(
0,
"DGN application name must hold at most 255 UTF-16 units and no NUL",
));
}
Ok(())
}
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[non_exhaustive]
pub struct StripSeedReport {
pub removed_graphic_records: u64,
pub removed_control_records: u64,
pub removed_control_types: BTreeMap<u16, u64>,
pub removed_auxiliary_records: u64,
pub removed_cell_definitions: u64,
pub removed_property_sets: u64,
pub removed_summary_properties: Vec<u32>,
pub removed_document_summary_properties: Vec<u32>,
pub kept_control_records: u64,
pub kept_control_types: BTreeMap<u16, u64>,
pub kept_raster_attachments: u64,
pub raster_file_references: u64,
pub dictionary_records: u64,
pub dictionary_pages_rewritten: u64,
pub levels: u64,
pub named_levels: u64,
pub fonts: u64,
pub tag_sets: u64,
pub cell_definitions: u64,
pub model_name_from_seed: bool,
pub model_description: bool,
pub unknown_streams: u64,
pub timestamp_ms: f64,
pub warnings: Vec<Warning>,
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct StrippedSeed {
pub bytes: Vec<u8>,
pub report: StripSeedReport,
}
pub fn strip_seed_v8(
seed: &[u8],
options: &StripSeedOptions,
read: &ReadOptions,
) -> Result<StrippedSeed> {
options.validate()?;
let mut read = read.clone();
read.keep_raw = true;
let input = V8Seed::parse(seed, &read)?;
let input_streams = container::read_streams(seed, &read)?;
let mut report = StripSeedReport::default();
let without_cells = if options.keep_cell_definitions {
None
} else {
let (bytes, removed) = remove_cell_definitions(&input, &read)?;
report.removed_cell_definitions = removed;
bytes
};
let reparsed;
let source = match &without_cells {
Some(bytes) => {
reparsed = V8Seed::parse(bytes, &read)?;
&reparsed
}
None => &input,
};
let mut doc = Document::default();
doc.units = source.units();
let mut model = Model::default();
model.is_3d = source.is_3d();
if options.keep_raster_template && source.has_raster_template() {
model.entities = seed_images(source.as_bytes(), &read)?;
}
doc.models.push(model);
let write = WriteOptions::new()
.with_limits(read.limits)
.with_codepage(read.fallback_codepage.clone())
.with_timestamp_ms(options.timestamp_ms)
.with_clear_seed_model(true)
.with_preserve_seed_rasters(true)
.with_preserve_seed_controls(options.keep_controls);
let written = super::write_v8_with_seed(&doc, source, &write)?;
let emptied = V8Seed::parse(&written, &read)?;
let model = emptied.model()?;
let header = emptied
.model_header()
.ok_or_else(|| Error::invalid(0, "missing seed model header"))?;
let newest_record = source
.native
.named_pages
.iter()
.chain(&model.graphic_pages)
.chain(&model.control_pages)
.flat_map(|p| &p.elements)
.filter_map(|e| le::f64_at(&e.bytes, ELEMENT_TIME))
.filter(|t| t.is_finite() && *t > 0.0)
.fold(0.0f64, f64::max);
let time = if options.timestamp_ms > 0.0 {
options.timestamp_ms.max(newest_record)
} else {
emptied.seed_timestamp_ms
};
let filetime = oleps::filetime(time);
let mut streams = container::read_streams(&written, &read)?;
let source_streams;
let dictionary_source = match &without_cells {
Some(bytes) => {
source_streams = container::read_streams(bytes, &read)?;
&source_streams
}
None => &input_streams,
};
streams.retain(|k, _| !is_dictionary_page(k));
streams.extend(
dictionary_source
.iter()
.filter(|(k, _)| is_dictionary_page(k))
.map(|(k, v)| (k.clone(), v.clone())),
);
let mut file_header = emptied.header_data.clone();
let max_id = model
.graphic_pages
.iter()
.chain(&model.control_pages)
.flat_map(|p| &p.elements)
.filter_map(RawElement::id)
.fold(source.max_id, u64::max);
u64_at(&mut file_header, HIGH_WATER_ID, max_id)?;
if time > 0.0 {
f64_at(&mut file_header, FILE_TIME, time)?;
}
let mut h = emptied.header_prefix.to_vec();
h.extend(compressed(&file_header)?);
streams.insert("Dgn~H".into(), h);
let mut element = header.raw.clone();
let old_time = element
.get(ELEMENT_TIME..ELEMENT_TIME + 8)
.map(<[u8]>::to_vec);
if time > 0.0 {
f64_at(&mut element, MODEL_TIME, time)?;
if le::f64_at(&element, ELEMENT_TIME).is_some_and(|t| t.is_finite() && t > 0.0) {
f64_at(&mut element, ELEMENT_TIME, time)?;
}
}
let new_time = element
.get(ELEMENT_TIME..ELEMENT_TIME + 8)
.map(<[u8]>::to_vec);
if let Some(name) = &options.model_name {
element = rename_model_header(&element, name, &read)?;
}
let mut mh = emptied.mh_prefix.clone();
mh.extend_from_slice(&element);
streams.insert(emptied.mh_path.clone(), compressed(&mh)?);
let time_change = match (&old_time, &new_time) {
(Some(old), Some(new)) if old != new => Some((old.as_slice(), new.as_slice())),
_ => None,
};
if options.model_name.is_some() || time_change.is_some() {
let storage = model.storage.trim_start_matches('#').parse::<u16>().ok();
let edited = streams.get("Dgn^Ix/Dgn~Mix").and_then(|raw| {
let inflated = crate::zlib::inflate(
raw,
usize::try_from(read.limits.max_decompressed_bytes).unwrap_or(usize::MAX),
);
if inflated.problem.is_some() {
return None;
}
edit_model_index(
&inflated.data,
storage?,
options.model_name.as_deref(),
time_change,
)
});
match edited {
Some(mix) => {
streams.insert("Dgn^Ix/Dgn~Mix".into(), compressed(&mix)?);
}
None => report.warnings.push(Warning::new(
"dgn.strip_model_index",
"the model index could not be edited; it keeps the seed's entry",
)),
}
}
let property_sets: Vec<String> = streams
.keys()
.filter(|k| k.rsplit('/').next().is_some_and(|l| l.starts_with('\u{5}')))
.cloned()
.collect();
for key in &property_sets {
streams.remove(key);
}
report.removed_property_sets = property_sets.len() as u64;
let summary = oleps::summary_information(&options.application, filetime)?;
let document_summary = oleps::document_summary_information()?;
report.removed_summary_properties = removed_ids(
input_streams
.get("\u{5}SummaryInformation")
.map(Vec::as_slice),
&summary,
);
report.removed_document_summary_properties = removed_ids(
input_streams
.get("\u{5}DocumentSummaryInformation")
.map(Vec::as_slice),
&document_summary,
);
streams.insert("\u{5}SummaryInformation".into(), summary);
streams.insert("\u{5}DocumentSummaryInformation".into(), document_summary);
let bytes = container::build(
&streams,
&BTreeSet::new(),
container::BuildMeta {
root_color: container::seed_root_color(&written),
filetime: filetime.unwrap_or(0),
},
&read,
)?;
let output = V8Seed::parse(&bytes, &read)?;
report.timestamp_ms = time;
count_model(source.model()?, output.model()?, &mut report);
count_dictionary(&output, &read, &mut report);
report.dictionary_pages_rewritten = input_streams
.iter()
.filter(|(k, _)| is_dictionary_page(k))
.filter(|(k, v)| streams.get(*k) != Some(*v))
.count() as u64
+ streams
.keys()
.filter(|k| is_dictionary_page(k) && !input_streams.contains_key(*k))
.count() as u64;
let out_header = output.model_header();
report.model_name_from_seed = options.model_name.is_none()
&& out_header
.and_then(|h| h.name.as_deref())
.is_some_and(|n| !n.is_empty());
report.model_description = out_header
.and_then(|h| h.description.as_deref())
.is_some_and(|d| !d.is_empty())
|| output
.native
.model_index
.iter()
.any(|e| !e.description.is_empty());
report.unknown_streams = streams.keys().filter(|k| !is_decoded_stream(k)).count() as u64;
Ok(StrippedSeed { bytes, report })
}
fn remove_cell_definitions(seed: &V8Seed, read: &ReadOptions) -> Result<(Option<Vec<u8>>, u64)> {
let mut records = Vec::new();
let mut removed = 0u64;
let mut in_cell = false;
for page in &seed.native.named_pages {
for raw in &page.elements {
if !raw.is_complex_component() {
in_cell = raw.type_code() == SHARED_CELL_DEFINITION;
removed += u64::from(in_cell);
}
if in_cell {
continue;
}
records.push(NamedRecord {
page: Some(page.number),
prefix: raw.prefix,
bytes: raw.bytes.clone(),
});
}
}
if removed == 0 {
return Ok((None, 0));
}
let mut replacements = BTreeMap::new();
named::write(
&mut replacements,
&seed.native.named_pages,
&seed.native.named_aux,
&records,
read.limits.max_decompressed_bytes,
)?;
Ok((
Some(container::rewrite(&seed.bytes, &replacements, read)?),
removed,
))
}
fn seed_images(seed: &[u8], read: &ReadOptions) -> Result<Vec<Entity>> {
let mut writer_read = ReadOptions::default()
.with_limits(read.limits)
.with_keep_raw(true);
writer_read.fallback_codepage = read.fallback_codepage.clone();
let doc = crate::read(seed, &writer_read)?;
let mut out = Vec::new();
let mut todo: Vec<&Entity> = doc.models.iter().flat_map(|m| &m.entities).collect();
while let Some(e) = todo.pop() {
match &e.kind {
EntityKind::Image { .. } if e.id.is_some() => {
let mut image = e.clone();
image.attributes.clear();
out.push(image);
}
EntityKind::Group { children, .. } => todo.extend(children),
_ => {}
}
}
out.sort_by_key(|e| e.id);
Ok(out)
}
fn rename_model_header(raw: &[u8], name: &str, read: &ReadOptions) -> Result<Vec<u8>> {
let attr = usize::try_from(le::u32_at(raw, 8).unwrap_or(0))
.unwrap_or(usize::MAX)
.saturating_mul(2)
.min(raw.len());
let primary = raw.get(..attr).unwrap_or(&[]);
let area = raw.get(attr..).unwrap_or(&[]);
let enc = crate::text::encoding_for(read.fallback_codepage.as_deref());
let links = linkage::parse(area, attr, true, enc);
let name_link = string_link(1, name)?;
let mut linkages = Vec::with_capacity(area.len() + name_link.len());
let mut end = 0usize;
let mut replaced = false;
for l in &links {
let start = l.offset.saturating_sub(attr);
end = start.saturating_add(l.bytes.len());
let is_name = matches!(l.data, LinkageData::String { string_id: 1, .. });
if is_name && !replaced {
linkages.extend_from_slice(&name_link);
replaced = true;
} else {
linkages.extend_from_slice(&l.bytes);
}
}
if !replaced {
linkages.extend_from_slice(&name_link);
}
linkages.extend_from_slice(area.get(end..).unwrap_or(&[]));
let mut out = primary.to_vec();
out.extend(linkages);
if out.len() % 2 == 1 {
out.push(0);
}
let words = u32::try_from(out.len() / 2)
.map_err(|_| Error::invalid(0, "DGN model header exceeds its length field"))?;
u32_at(&mut out, 4, words)?;
Ok(out)
}
fn edit_model_index(
mix: &[u8],
storage: u16,
name: Option<&str>,
time: Option<(&[u8], &[u8])>,
) -> Option<Vec<u8>> {
if le::u32_at(mix, 0)? != MODEL_INDEX_MAGIC {
return None;
}
let count = le::u32_at(mix, 8)? as usize;
let mut out = mix.get(..16)?.to_vec();
let mut off = 16usize;
let mut found = false;
for _ in 0..count.min(mix.len() / MODEL_INDEX_ENTRY) {
let size = usize::from(le::u16_at(mix, off + 16)?);
let entry = mix.get(off..off.checked_add(size)?)?;
if size < MODEL_INDEX_ENTRY {
return None;
}
if found || le::u32_at(entry, 0)? & 0xffff != u32::from(storage) {
out.extend_from_slice(entry);
off += size;
continue;
}
found = true;
let name_len = usize::from(le::u16_at(entry, 18)?);
let desc_len = usize::try_from(le::u32_at(entry, 20)?).ok()?;
let name_end = MODEL_INDEX_ENTRY.checked_add(name_len)?;
let desc_end = name_end.checked_add(desc_len)?;
let mut head = entry.get(..MODEL_INDEX_ENTRY)?.to_vec();
let new_name = match name {
Some(n) => n.encode_utf16().flat_map(u16::to_le_bytes).collect(),
None => entry.get(MODEL_INDEX_ENTRY..name_end)?.to_vec(),
};
if let Some((old, new)) = time
&& head.get(8..16) == Some(old)
{
put(&mut head, 8, new).ok()?;
}
if desc_end > size {
return None;
}
let rest = entry.get(name_end..)?;
let new_size = u16::try_from(size - name_len + new_name.len()).ok()?;
put(&mut head, 16, &new_size.to_le_bytes()).ok()?;
put(
&mut head,
18,
&u16::try_from(new_name.len()).ok()?.to_le_bytes(),
)
.ok()?;
out.extend(head);
out.extend(new_name);
out.extend_from_slice(rest);
off += size;
}
out.extend_from_slice(mix.get(off..)?);
found.then_some(out)
}
fn removed_ids(before: Option<&[u8]>, after: &[u8]) -> Vec<u32> {
let kept: BTreeSet<u32> = oleps::property_ids(after).into_iter().collect();
before
.map(oleps::property_ids)
.unwrap_or_default()
.into_iter()
.filter(|id| !kept.contains(id))
.collect::<BTreeSet<_>>()
.into_iter()
.collect()
}
fn count_model(before: &V8Model, after: &V8Model, report: &mut StripSeedReport) {
let records = |pages: &[Page]| pages.iter().map(|p| p.elements.len() as u64).sum::<u64>();
let types = |pages: &[Page]| {
let mut out: BTreeMap<u16, u64> = BTreeMap::new();
for raw in pages.iter().flat_map(|p| &p.elements) {
*out.entry(raw.type_code()).or_default() += 1;
}
out
};
let aux = |m: &V8Model| {
m.graphic_aux
.iter()
.chain(&m.control_aux)
.map(|p| p.records.len() as u64)
.sum::<u64>()
};
report.removed_graphic_records =
records(&before.graphic_pages).saturating_sub(records(&after.graphic_pages));
report.kept_control_records = records(&after.control_pages);
report.removed_control_records =
records(&before.control_pages).saturating_sub(report.kept_control_records);
report.kept_control_types = types(&after.control_pages);
let mut removed = types(&before.control_pages);
for (t, n) in &report.kept_control_types {
if let Some(count) = removed.get_mut(t) {
*count = count.saturating_sub(*n);
}
}
removed.retain(|_, n| *n > 0);
report.removed_control_types = removed;
report.removed_auxiliary_records = aux(before).saturating_sub(aux(after));
let kept = |pages: &[Page], t: u16| {
pages
.iter()
.flat_map(|p| &p.elements)
.filter(|r| r.type_code() == t && !r.is_complex_component())
.count() as u64
};
report.kept_raster_attachments = kept(&after.graphic_pages, 94);
report.raster_file_references = kept(&after.control_pages, 90);
}
fn count_dictionary(seed: &V8Seed, read: &ReadOptions, report: &mut StripSeedReport) {
let enc = crate::text::encoding_for(read.fallback_codepage.as_deref());
for raw in seed.native.named_pages.iter().flat_map(|p| &p.elements) {
report.dictionary_records += 1;
if raw.type_code() == SHARED_CELL_DEFINITION && !raw.is_complex_component() {
report.cell_definitions += 1;
continue;
}
if !matches!(raw.type_code(), 39 | 95 | 96) {
continue;
}
match decode_v8::decode_with(raw, enc, &read.limits).data {
ElementData::Level(level) => {
report.levels += 1;
report.named_levels += u64::from(level.name.is_some_and(|n| !n.is_empty()));
}
ElementData::Font { .. } => report.fonts += 1,
ElementData::TagSet(_) => report.tag_sets += 1,
_ => {}
}
}
}
fn is_dictionary_page(key: &str) -> bool {
key.starts_with("Dgn^Nm/") || key.starts_with("Dgn^NmA/")
}
fn is_decoded_stream(key: &str) -> bool {
key == "Dgn~H"
|| key == "Dgn^Ix/Dgn~Mix"
|| key == "\u{5}SummaryInformation"
|| key == "\u{5}DocumentSummaryInformation"
|| is_dictionary_page(key)
|| key.strip_prefix("Dgn-Md/").is_some_and(|rest| {
rest.split_once('/').is_some_and(|(_, leaf)| {
leaf == "Dgn~Mh"
|| ["Dgn^G/", "Dgn^C/", "Dgn^GA/", "Dgn^CA/"]
.iter()
.any(|p| leaf.starts_with(p))
})
})
}