diff --git a/crates/step/src/geom_tests.rs b/crates/step/src/geom_tests.rs index 244aa2aee..a1c9bf237 100644 --- a/crates/step/src/geom_tests.rs +++ b/crates/step/src/geom_tests.rs @@ -415,6 +415,35 @@ fn hostile_geometry_is_an_error_never_a_panic() { } } +/// A curve whose definition leads back to itself, directly or through another curve, is refused +/// with an error that names a curve of the loop. A 2D trimmed curve in a pcurve used to follow +/// its basis without the depth check of the other readers, until the stack overflowed and the +/// app closed; here it is reached both as a surface curve and as the profile of a face's surface. +#[test] +fn a_curve_that_refers_to_itself_is_an_error_never_a_crash() { + let trimmed = |id: u64, basis: u64| format!("#{id}=TRIMMED_CURVE('',#{basis},(PARAMETER_VALUE(0.)),(PARAMETER_VALUE(1.)),.T.,.PARAMETER.);"); + for curves in [trimmed(20, 20), trimmed(20, 21) + &trimmed(21, 20)] { + let ex = file(&format!( + "{BASE}#10=PLANE('',#4);#11=VECTOR('',#3,1.);#12=LINE('',#1,#11);\ + #13=(GEOMETRIC_REPRESENTATION_CONTEXT(2)PARAMETRIC_REPRESENTATION_CONTEXT()REPRESENTATION_CONTEXT('2D SPACE',''));\ + {curves}#14=DEFINITIONAL_REPRESENTATION('',(#20),#13);#15=PCURVE('',#10,#14);#16=SURFACE_CURVE('',#12,(#15),.CURVE_3D.);\ + #17=SURFACE_OF_LINEAR_EXTRUSION('',#16,#11);" + )); + let read = [Reader::new(&ex, MM).curve(16).map(|_| ()), Reader::new(&ex, MM).surface(17).map(|_| ())]; + for got in read { + let Err(e) = got else { panic!("read although it refers to itself: {curves}") }; + assert!(e.contains("curve #20") || e.contains("curve #21"), "{e}"); + } + } + // A 3D curve and a surface that refer to themselves name themselves too. + let ex = file(&format!("{BASE}{}", trimmed(10, 10))); + let e = Reader::new(&ex, MM).curve(10).err().unwrap_or_default(); + assert!(e.contains("curve #10"), "{e}"); + let ex = file(&format!("{BASE}#10=OFFSET_SURFACE('',#10,1.,.F.);")); + let e = Reader::new(&ex, MM).surface(10).err().unwrap_or_default(); + assert!(e.contains("surface #10"), "{e}"); +} + /// Every edge curve and face surface of every STEP file in `SOLIDCRAFT_STEP_CORPUS` (the /// tangency-labs/models files): read, written, read back. Run with `--ignored`. #[test] diff --git a/crates/step/src/read.rs b/crates/step/src/read.rs index f9c9c11fa..36b2ba40c 100644 --- a/crates/step/src/read.rs +++ b/crates/step/src/read.rs @@ -13,7 +13,10 @@ use crate::p21::{Entity, Exchange, Param}; pub type R = Result; -/// Geometry nesting we follow (a trimmed curve of a surface curve of …). +/// Geometry nesting we follow (a trimmed curve of a surface curve of …). Real files nest a few +/// levels; the cap bounds the stack, and it is what ends a curve or surface whose definition leads +/// back to itself, so every curve and surface read checks it (`read_curve`, +/// `read_surface`). pub const MAX_GEOM_DEPTH: usize = 12; /// Most control points in one B-spline (the whole net for a surface). pub const MAX_CTRL: usize = 1_000_000; @@ -385,9 +388,6 @@ impl<'a> Reader<'a> { if let Some(c) = self.curves.get(&id) { return Ok(c.clone()); } - if depth > MAX_GEOM_DEPTH { - return Err("curve definitions nested too deeply".into()); - } let l = self.units.len; let c = Arc::new(self.read_curve(id, [l, l, l], 3, depth)?); self.curves.insert(id, c.clone()); @@ -401,9 +401,6 @@ impl<'a> Reader<'a> { if let Some(c) = self.curves_2d.get(&key) { return Ok(c.clone()); } - if depth > MAX_GEOM_DEPTH { - return Err("curve definitions nested too deeply".into()); - } let c = Arc::new(self.read_curve(id, s, 2, depth)?); self.curves_2d.insert(key, c.clone()); Ok(c) @@ -425,7 +422,12 @@ impl<'a> Reader<'a> { Ok(s[0]) } + /// Every curve is read here, the basis of a 2D trimmed curve too, so the depth check here + /// ends every chain of curve references, a cycle included. fn read_curve(&mut self, id: u64, s: [f64; 3], dim: usize, depth: usize) -> R { + if depth > MAX_GEOM_DEPTH { + return Err(format!("curve #{id}: definitions nested more than {MAX_GEOM_DEPTH} deep, or referring to themselves")); + } let e = entity(self.ex, id)?; if e.is_complex() { return self.bspline_curve(e, s, dim); @@ -633,15 +635,15 @@ impl<'a> Reader<'a> { if let Some(s) = self.surfaces.get(&id) { return Ok(s.clone()); } - if depth > MAX_GEOM_DEPTH { - return Err("surface definitions nested too deeply".into()); - } let s = Arc::new(self.read_surface(id, depth)?); self.surfaces.insert(id, s.clone()); Ok(s) } fn read_surface(&mut self, id: u64, depth: usize) -> R { + if depth > MAX_GEOM_DEPTH { + return Err(format!("surface #{id}: definitions nested more than {MAX_GEOM_DEPTH} deep, or referring to themselves")); + } let e = entity(self.ex, id)?; if e.is_complex() { return self.bspline_surface(e);