Compare commits

..
49 Commits
Author SHA1 Message Date
Tanish Manku 198c36b406 Merge #2765: images refuse oversized data before decoding 2026-11-19 15:33:03 -07:00
Tanish Manku 2101a81d62 Merge #2821: hostile-input fixes for SVG import and AutoLISP step accounting
No textual conflict, but main's #2072 (Nov 18) and this PR both fixed the
transformed-ellipse axis: #2072 takes the eigenvector of B*B^T (a drawing-
plane direction), this PR the eigenvector of B^T*B mapped through B. The
clean merge mixed the two (B*B^T's eigenvector mapped through B again).
Kept #2072's computation and this PR's convention that `major` is the axis
from the centre: major = axis * s_max. #2072's test measured `major - centre`
(the old absolute-point convention); it now reads `major` itself.
2026-11-19 15:32:44 -07:00
Tanish Manku 2827ccb6c8 Merge #2820: SHX fonts: a points bound on the glyph cache 2026-11-19 15:31:26 -07:00
Tanish Manku 8ec1e9a0a5 Stack t1: #1276: the reader's band reservations end with the read
reserved_handles only bridges a record read before its section is placed.
Kept on the drawing it was cloned with every undo snapshot, one entry per
band handle a file names. Once every record is placed the objects keep their
handles from new ones themselves, so the reader empties it.
2026-11-19 15:30:55 -07:00
Tanish Manku b184454275 Stack t1: #1276: run the exhausted-handles DXF round trip (#1921)
The writer now numbers its records past the top of the range in the
reserved band, skipping the drawing's handles, so the save no longer
repeats the model space record's handle.
2026-11-19 15:30:10 -07:00
Tanish Manku 077c054d18 Stack t1: #1276: bound the writer's handle walk
W::next_handle looped until it found a free handle; with the wrap into the
reserved band it could only end by finding one. Bound it by the count of
handles in use, as Drawing::next_handle is. Not reachable in practice (it
needs four billion objects), so there is no test.
2026-11-19 15:29:58 -07:00
Tanish Manku 5eafcc93bb Stack t1: #1276: records added on save after the top handle take free handles
Kept objects and missing application ids are numbered above the largest
handle written. When a file's object holds FFFFFFFFFFFFFFFF that count
saturated, so every added record was written with the object's handle.
Number them past the top in the reserved band instead, skipping handles
already written, with the walk bounded by their count.
2026-11-19 15:29:48 -07:00
Tanish Manku 7c366f7b5a Merge #1276: a handle at the top of the range leaves new objects their own
Conflict in Drawing::new_handle/next_handle with #2514. The resolution keeps
both rules: next_handle (HANDSEED) skips the handles of the file's objects
CADCraft rewrites (foreign.handles, #2514), and in the reserved band above
HANDLE_LIMIT also every handle an object or a reserved file record holds
(#913, #1921); off the top of the range it continues at the bottom of the
band, and new_handle takes exactly what next_handle reports.

The scan over all spaces and block definitions runs only for a candidate in
the band: below it the seed is kept above every object's handle. The walk is
bounded by the count of held handles, counted only once a handle is skipped.
2026-11-19 15:29:11 -07:00
moandClaude Opus 5.5 a39d637814 Merge remote-tracking branch 'origin/main' into parsers-hostile
crates/io/src/svg_read.rs is taken from main (c07b6a2f, the craft-svg based reader) and every SVG fix of this branch is re-applied on top of it, since all of them sit in the conversion of craft-svg's neutral_document shapes into entities, which stays on the cadcraft side: in add_rounded, the ellipse's major axis is the image B*v of the leading eigenvector (relative to the centre, so a rotated ellipse keeps its turn and a sheared circle gets the axes of its image) and the near-orthogonal test scales with the trace instead of a floor of 1 (tiny sheared circle); in add, an entity whose coordinates or extents are not finite (finite, box_finite, bulges_finite) is left out after it is charged against the vertex budget, and counted for a read note of its own, made by notes() apart from the note on what isn't read yet. Nothing is dropped: craft-svg's neutral_document::visit and path_data::parse_path only refuse non-finite numbers as written, not relative steps or transforms that overflow them; the overflow checks of craft-libs#881 (paths.rs, smooth_segments_after_a_close_relative_root_sizes_and_overflowing_steps) cover craft-svg's own paths::import, which cadcraft does not use. Against main's svg_read.rs alone, svg_ellipse_major_axis_is_relative_to_its_centre, svg_rotated_ellipse_keeps_its_turn, svg_sheared_circle_has_the_axes_of_its_image, svg_tiny_sheared_circle_has_the_axes_of_its_image, svg_coordinates_that_overflow_are_left_out, svg_shapes_whose_extents_overflow_are_left_out, svg_too_large_shapes_are_noted_apart_from_unread_content and svg_shapes_become_entities_in_millimetres fail; with the fixes re-applied they pass unchanged. No test is changed or removed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 20:28:18 -05:00
moandClaude Opus 5.5 dc7e5cdd6e Merge remote-tracking branch 'origin/main' into shx-hostile
Main's SHX compiler, container reader and glyph interpreter now come from
craft-shx (#3193, #3194, #3195), so this branch's changes to compile.rs,
parse.rs and program.rs are dropped here (they move to a craft-libs pull
request) and only the points-budgeted glyph cache in mod.rs remains. The
tests of the moved code are removed with it:
a_far_extended_subshape_cell_is_cut_off,
subshape_fan_out_past_the_point_and_step_bounds_is_cut_off,
a_name_is_looked_for_in_its_first_kilobyte_only,
a_name_the_reader_would_drop_does_not_compile,
all_65535_shape_numbers_compile_and_a_repeat_is_found and
a_doubled_minus_sign_is_not_a_number.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 20:21:35 -05:00
midasmatterhorn e4f9b6aae3 io: the helper also checks the owner of the handle below the band 2026-11-15 22:03:05 +03:00
midasmatterhorn 140437e78e io: reserve a file's band handles before numbering handle-less entities
The handle pre-scan moves the seed past a file's ordinary handles, but
bump_handseed deliberately does not follow one at or above HANDLE_LIMIT
(#913). A handle-less entity read earlier is therefore numbered with the
band's first handle while the ENTITIES record that names it is still
unplaced; when the record is placed, EntityStore::push replaces the file's
entity with the generated handle.

Record the band handles the entity records of BLOCKS and ENTITIES name for
allocation, and have new_handle skip them. Reservation stays separate from
seed bumping: bump_handseed still ignores the reserved band, and a file's
band handles keep their identity.

Tests: a file whose handle-less model-space BLOCKS entity would take the
HANDLE_LIMIT handle of an ENTITIES record, with and without the CADCraft
seed record, keeps all three lines and their handles. Both fail without the
reservation (2 of 3 lines survive).
2026-11-14 18:40:40 +03:00
midasmatterhorn 528e2698fe io: reserve entity handles per section and give generated geometry free handles
Two holes in the handle bookkeeping, both found while checking the review:

- A CADCraft-marked file skips the handle pre-scan, so a handle-less entity
  in BLOCKS took a fresh handle the reader could hand out before a later
  ENTITIES record named the same handle; the second entity then replaced the
  first. Reserve the file's entity handles across BLOCKS and ENTITIES before
  anything is parsed, for marked files too. BLOCK and ENDBLK stay out, so
  structural handles do not move the saved seed.
- Generated dimension/arrowhead/table geometry read the writer's cursor
  directly. After the cursor skips an occupied handle its next value can be
  occupied too, so the generated records could reuse one of the drawing's
  handles; take them from next_handle, which skips every used handle.

Tests: a marked file with a handle-less block entity and an ENTITIES record
naming the same handle, and a drawing whose band handles make the writer wrap
while saving a dimension, both keep every handle distinct.
2026-11-14 17:18:05 +03:00
midasmatterhorn 764204540a engine: AUDIT finds ordinary handles behind a reserved-band one
A handle at or above HANDLE_LIMIT is deliberately not followed, but taking
the maximum over every handle let one such handle hide every ordinary one
behind it: the seed was never repaired past them and AUDIT reported a clean
drawing. Leave the reserved band out of the maximum, and cover a drawing
with both kinds of handle.
2026-11-14 17:17:20 +03:00
midasmatterhorn a516ce11eb io: a seed in the reserved band never hands out a handle an object holds
new_handle takes the first handle at or above the seed that no space or block
definition uses, wrapping into the band above HANDLE_LIMIT at the top of the
range. The writer's structural records skip the drawing's handles too, so a
file whose own handles sit at the bottom of the band is saved with distinct
records. AUDIT no longer reports the preserved top handles as a seed error its
own repair never fixes.
2026-11-13 00:03:08 +03:00
midasmatterhorn 03baa73ae5 Merge remote-tracking branch 'upstream/main' into pr-1276 2026-11-12 23:15:16 +03:00
moandClaude Opus 5.5 797c5df792 Merge remote-tracking branch 'origin/main' into parsers-hostile
main's #2741 makes nested callbacks share one allowance through
callback_used/callback_ceiling, which replaces this branch's own cap check in
call_sync. This branch's list-walk work counting, now also charged to
callback_used inside a callback, and the charging of a callback's work to its
caller's step are kept on top, through a callback_work field so that work is
not counted against callback_used twice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 05:04:09 -05:00
wovadiandClaude Opus 5.5 736f56d320 Images: the full-path check is for builds that read files
`full_path` serves only the file read, which the web build doesn't have: it is
left out there, so the wasm check has no dead-code warning for it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:33:17 +01:00
wovadi a9b93676a4 Merge remote-tracking branch 'origin/main' into fix/image-attach-limits 2026-11-10 16:20:05 +01:00
wovadiandClaude Opus 5.5 19fc1f20be Images: line breaks in data don't count toward its limit; full Windows paths get no hint
Review follow-ups on #2765:
- The length check before decoding counts the base64 characters, not the line
  breaks and spaces decoding skips, so MIME-wrapped data of a file just under
  256 MB is taken. The whole text is still bounded (6% over the limit), which
  also bounds what decoding sets aside.
- A full Windows path (a drive or a share), which Linux and macOS read as
  relative, no longer gets "save the drawing first, or give a full path".
- The test sends text that isn't base64, so only the check before decoding
  gives the size message, and it no longer builds 0.6 GB.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 16:20:05 +01:00
moandClaude Opus 5.5 31866fcf05 Merge remote-tracking branch 'origin/main' into parsers-hostile
The relative-height cap in crates/fonts/src/mtext.rs is taken from main (#1036),
which bounds a compounding `\H…x;` to 1e-3..1e3 times the MTEXT's own height; the
MAX_HEIGHT cap and its test from f13a1f2e are dropped as redundant.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 06:38:11 -05:00
moandClaude Opus 5.5 ed8555875a LISP: a routine is charged the work its slices did
The driver added the slice length at each yield, so one step walking a
long list or running a long synchronous callback was charged as 400000
steps and a blocking routine could pass its cap by that work. It now adds
the machine's used steps after every slice and stops a waiting blocking
routine once they pass the cap.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 10:40:50 -05:00
moandClaude Opus 5.5 6f862d7b4b SVG import: a tiny sheared ellipse keeps the axes of its image
The orthogonal-axes test now scales with the shape instead of using an
absolute floor, so a sub-micrometre sheared circle no longer takes one
of its skewed columns as the major axis.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 10:06:20 -05:00
moandClaude Opus 5.5 b1a34dc0ef SVG import: a rotated or sheared ellipse keeps the orientation of its image
The major axis was the leading eigenvector of the basis's Gram matrix scaled
to the semi-major length, but that eigenvector is a direction in the
ellipse's parameter space, not in the drawing, so a rotated ellipse came in
axis-aligned. The major axis is now that direction mapped through the basis.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 09:33:59 -05:00
moandClaude Opus 5.5 f24da7a85b SVG import: shapes too large to represent are noted as invalid, apart from what isn't read yet
A shape whose coordinates or extents overflow was listed under "CADCraft
doesn't read these yet", as if support were missing; the file itself is at
fault. Such shapes now get a read note of their own saying they were left out
as invalid, and the note on unread content keeps its wording.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 08:59:25 -05:00
moandClaude Opus 5.5 6a240a7076 SVG import: the finiteness check names every entity kind, so a new one must be decided
`finite` ended in a wildcard that passed any other kind unchecked, so a kind
the reader came to make later would skip the check silently. The kinds the
reader doesn't make are now listed, and a new `EntityKind` variant fails to
compile until it is placed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 08:58:18 -05:00
moandClaude Opus 5.5 f903621540 LISP: the long-list slice test measures the walk's charge, not the time it takes
The test ran `(while t (length l))` through the session and passed on main as
well, where the first slice walked the list for its whole budget before
yielding. It now builds a 32768-cell list in one run and gives a single
`(length l)` a 1000-step slice: the slice yields after the walk and the run
reports more than 32768 steps, where counting the walk as one step finished
`length` inside the slice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 08:57:57 -05:00
moandClaude Opus 5.5 063cbef279 SVG import: a shape whose extents overflow is left out too, not only one whose coordinates do
A circle with a finite centre and radius can still reach past the largest
number (`<circle cx="1" r="1"/>` under `scale(1e308)`), and so can an ellipse
whose box is wider than its axis or a polyline arc between finite vertices;
their bounds came out infinite or silently cut short. Such a shape is now left
out and counted in the read note like one with overflowing coordinates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 07:19:56 -05:00
moandClaude Opus 5.5 51f38b4eda SVG import: a shape left out for overflowing coordinates still counts against the vertex budget
The finiteness check came before the vertex charge, so a left-out shape cost
nothing, and a file of paths flattening to non-finite vertices did all that
work where the 8,000,000-vertex budget used to stop it. Each shape is now
charged first and then checked.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 07:15:23 -05:00
moandClaude Opus 5.5 348d767b93 LISP: each synchronous callback's cap counts only its own steps
Work the caller had queued before a callback (its list walks, and the charged
steps of the callbacks before it in the same step) was drained into the
callback's own count, so a `vl-sort` comparison counted every earlier
comparison too and the per-callback cap held for the whole sort. That work is
now set aside when a callback starts and charged back with the callback's own
steps, so the enclosing run still sees all of it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 07:15:23 -05:00
moandClaude Opus 5.5 82779b50d0 SHX fonts: shape source with a name over 1,024 bytes is an error
The reader drops a record whose name runs on past 1,024 bytes, so such a source compiled into
a file without that shape. The error names the line of the definition.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 07:09:13 -05:00
moandClaude Opus 5.5 09d2e06862 SHX fonts: a glyph outlined by two threads at once is counted in the cache once
Both missed the cache, both outlined, and the second insert replaced the first entry while
its points were added again, so the point bound cleared the cache early. The later thread
now takes the entry already there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 07:08:22 -05:00
moandClaude Opus 5.5 16e0fa5293 SVG import: an ellipse's major axis is relative to its centre, not a point
`Ellipse::major` is a vector from the centre everywhere else (the DXF reader
and writer keep group 11 as the DXF Reference defines it, and rendering takes
its length as the radius), but the SVG reader stored the absolute point
centre + axis, so every ellipse away from the origin, and every circle under a
non-uniform transform, came in with the wrong axis length and direction. The
existing shapes test measured `major - center` and so passed with the absolute
point; it now reads `major` as the vector.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 00:21:17 -05:00
moandClaude Opus 5.5 f13a1f2e39 MTEXT: a relative height code grows no further than the largest absolute one
`\H1000x;` multiplied the current height each time it was read, so a run of
them made the height infinite and the laid-out strokes and bounds infinite or
NaN. A relative height now stops at the 1e6 an absolute `\H` may set (or the
height it starts from, when that is larger).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 00:16:17 -05:00
moandClaude Opus 5.5 44b0399aa6 LISP: a step's list walking and callback steps count against the slice, so a routine always yields
A machine step counted as one whatever it did: `(while t (length l))` over a
long list walked 400000 lists per slice and never gave the interface a frame,
and a callback retrying an endless inner callback gave each try a fresh cap
(10000^3 steps at three levels). List cells walked and the steps of synchronous
callbacks now count as steps of the step that made them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 00:16:17 -05:00
moandClaude Opus 5.5 bb91014ebd SHX fonts: shape source finds a repeated shape number with a set, not a scan
Each definition was compared with every one before it: 65,535 shapes (an 821 KB source)
took 2.8 s to compile. The error still names the line of the repeat.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:53:42 -05:00
moandClaude Opus 5.5 b439879181 SHX fonts: look for a shape name's terminator in its first 1,024 bytes only
Big font index entries may point anywhere, so their records may overlap: 65,535 entries over
one 64 KB run without a NUL were each searched to the end, 4 G bytes and 1.7 s to read a
576 KB file (83 ms now). A record whose name runs on is dropped, as one without a terminator
was.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:53:42 -05:00
moandClaude Opus 5.5 5154f5757b SHX fonts: bound a font's glyph cache by its points as well as its glyphs
The cache was bounded only by count (16,384 glyphs), so a font whose glyphs are all at the
point bound could keep 2 GB alive for as long as it stays loaded. It is now also cleared
before it holds more than 2^20 points (16 MB).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:53:42 -05:00
moandClaude Opus 5.5 661e5e2dd9 SHX fonts: bound a glyph to 8,192 points and 32,768 steps
Every character of a text may draw a glyph's full budget, so the budget is what a small
hostile font multiplies: with 50,000 points and 200,000 steps an 11 KB font drew a
1,000-character line in 3 s and 1.7 GB, and a 21 KB one took 6.4 s to measure 2,000
characters. The new bounds still leave 128 full circles or 16 shapes of the format's
2,000 bytes per glyph.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:53:42 -05:00
moandClaude Opus 5.5 225407ca61 SHX fonts: an extended big font subshape cell is held to the coordinate bound
The cell offset of code 7,0 moved the pen without the check every other move has: nested
255-unit cells put it 255^n units away, and a location pushed there and popped became the
advance (1e33) or a stroke's first point past the bound.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:53:42 -05:00
moandClaude Opus 5.5 01c003e407 SHX fonts: a shape source number with a doubled minus sign is an error, not an overflow
`--9223372036854775808` (or `-0-8000000000000000`) parsed its digits to i64::MIN and then
negated it, which panics with overflow checks on; any other doubled minus read as the
magnitude, so `*BIGFONT 4,--9223372036854775807` pushed escape ranges until 8 GB failed to
allocate (a 92-million count from a 161-byte source took 512 MB). Magnitudes must be
0..=0xFFFF.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:53:42 -05:00
moandClaude Opus 5.5 50644fb0c4 SVG import: shapes whose coordinates overflow to infinity or NaN are left out and noted
Finite numbers still overflow through transforms and relative path steps
(`M1e308 0 l1e308 0`, `scale(1e308)`), and the reader added the entities with
infinite or NaN coordinates, which break extents and rendering and change on a
DXF save. Such a shape is now skipped and counted in the read note.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 23:46:54 -05:00
zwork 23c55fc1a8 io: drop the renumbering plumbing the handle fix no longer needs 2026-11-04 17:51:09 +03:00
zwork 1a1d8404b6 io: a handle near the top of the range keeps its identity
Merged current main, which keeps a file's handles exactly as written: the
branch no longer renumbers them. A seed above HANDLE_LIMIT is not followed,
so new objects are allocated from the reserved range and never replace the
file's own object (#913). Round-trip handles near 2^64 survive a save.
2026-11-04 17:50:39 +03:00
wovadiandClaude Opus 5.5 f998f2f663 Images: check the decoded size of data too
Review follow-up on #2765: the longest base64 text allowed can hold one or two
bytes more than the 256 MB limit (it is not a multiple of three), so the decoded
bytes are checked against the limit as well. The length check before decoding
stays, to bound the allocation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 10:35:33 +01:00
wovadiandClaude Opus 5.5 f91d5ad38f Images: refuse oversized data before decoding, and say what to do with a relative path in an unsaved drawing
Follow-up to #2505: imageattach checks the length of base64 data against the
256 MB image limit before decoding it, and a relative path in an unsaved drawing
reports "save the drawing first, or give a full path".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 08:52:45 +01:00
midasmatterhorn aaaf654872 io: a group, sortents table or dimension link follows the entity the reader renumbered 2026-10-29 22:42:19 +03:00
midasmatterhorn cfc4fc5e88 Merge remote-tracking branch 'upstream/main' into fix-1276
# Conflicts:
#	crates/io/src/dxf_read.rs
2026-10-29 22:37:45 +03:00
midasmatterhorn bcac20dd5f io: a handle at the top of the range leaves new objects their own 2026-10-15 00:25:48 +03:00
76 changed files with 1293 additions and 3808 deletions
Generated
-1
View File
@@ -668,7 +668,6 @@ dependencies = [
"pollster 1.0.1",
"rfd",
"ron",
"serde",
"serde_json",
"sys-locale",
"thiserror 2.0.21",
+1 -1
View File
@@ -47,7 +47,7 @@ clap_mangen = { version = "0.3.3", features = ["env"] }
thiserror = "2"
same-file = "1"
serde = { version = "1", features = ["derive", "rc"] }
serde_json = { version = "1", features = ["float_roundtrip", "raw_value"] }
serde_json = { version = "1", features = ["float_roundtrip"] }
log = "0.4"
# All date/time conversion goes through chrono (no hand-rolled calendar code beyond the 400-year range extension; AGENTS.md).
chrono = { version = "0.4.45", default-features = false, features = ["std"] }
-2
View File
@@ -208,8 +208,6 @@ The logger is `apps/cadcraft/src/logging.rs`; the web build logs to the browser
cadcraft-cli mcp
# …or bridged to the running app (start it with --control 7979):
cadcraft-cli mcp --connect 127.0.0.1:7979
# …or headless, with the agent confined to a work folder:
cadcraft-cli mcp --automation-read-root ~/work --automation-write-root ~/work/out
# One-shot headless runs:
cadcraft-cli run --sample --script 'CIRCLE 22,3 1\n' --save out.dxf --export out.png
+6 -42
View File
@@ -276,13 +276,6 @@ pub(crate) struct McpArgs {
/// port first (macOS)
#[arg(long, requires = "connect")]
pub(crate) launch: bool,
/// The only folder the agent's commands may read from; reads are also allowed under the write
/// root (headless only)
#[arg(long, value_name = "DIR")]
pub(crate) automation_read_root: Option<String>,
/// The only folder the agent's commands may write to, never the folder itself (headless only)
#[arg(long, value_name = "DIR")]
pub(crate) automation_write_root: Option<String>,
#[command(flatten)]
pub(crate) settings: Settings,
}
@@ -415,18 +408,12 @@ enum UsageError {
/// The output is one of the input files, so writing it would replace the original.
#[error("{} is an input file, so the result would replace the original: choose another output, or pass --in-place to overwrite it", .0.display())]
OutIsInput(PathBuf),
/// The automation roots confine the headless server; a running app enforces its own access.
#[error(
"--automation-read-root and --automation-write-root confine the headless MCP server; a running app enforces its own file access (not yet available: see issue #1585)"
)]
AutomationRootsNeedHeadless,
}
impl UsageError {
/// This error in clap's form, so it prints with the usual usage text.
fn into_clap(self, cmd: &mut clap::Command) -> clap::Error {
let kind = match self {
Self::FramingNeedsImage { .. } | Self::OutIsInput(_) | Self::AutomationRootsNeedHeadless => ErrorKind::ArgumentConflict,
Self::FramingNeedsImage { .. } | Self::OutIsInput(_) => ErrorKind::ArgumentConflict,
};
cmd.error(kind, self)
}
@@ -498,13 +485,6 @@ fn framing_error(cli: &Cli) -> Option<UsageError> {
(!cadcraft_io::is_image(out)).then(|| UsageError::FramingNeedsImage { flag, out: out.to_path_buf() })
}
/// The automation roots confine the headless server only, as the other Craft apps' do.
fn roots_need_headless(cli: &Cli) -> Option<UsageError> {
let Command::Mcp(m) = &cli.command else { return None };
(m.connect.is_some() && (m.automation_read_root.is_some() || m.automation_write_root.is_some()))
.then_some(UsageError::AutomationRootsNeedHeadless)
}
/// An output that is the same file as an input, without `--in-place`. An output that doesn't exist
/// can't be an input, and an I/O error in the comparison is left to the open or write that follows.
fn out_is_input(cli: &Cli) -> Option<UsageError> {
@@ -523,20 +503,19 @@ fn out_is_input(cli: &Cli) -> Option<UsageError> {
/// The backend `cadcraft-cli mcp` serves from.
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum McpTarget {
/// An in-process drawing session (no `--connect`), optionally confined to the two folders.
Headless { read_root: Option<String>, write_root: Option<String> },
/// An in-process drawing session (no `--connect`).
Headless,
/// The running app's control channel at `HOST:PORT`; `lazy`: reached at the first call;
/// `launch`: opened then if it isn't running.
Connect { addr: String, lazy: bool, launch: bool },
}
impl McpArgs {
/// What these arguments ask the server to talk to.
pub(crate) fn target(&self) -> McpTarget {
match &self.connect {
// `--launch` connects at the first call too (the app opens then).
Some(addr) => McpTarget::Connect { addr: addr.clone(), lazy: self.lazy || self.launch, launch: self.launch },
None => McpTarget::Headless { read_root: self.automation_read_root.clone(), write_root: self.automation_write_root.clone() },
None => McpTarget::Headless,
}
}
}
@@ -609,7 +588,7 @@ fn parse_with(mut cmd: clap::Command, args: &[OsString]) -> Result<Cli, clap::Er
if let (Command::Run(r), Some((_, m))) = (&mut cli.command, matches.subcommand()) {
(r.drawings, r.steps) = run_order(m);
}
if let Some(e) = framing_error(&cli).or_else(|| out_is_input(&cli)).or_else(|| roots_need_headless(&cli)) {
if let Some(e) = framing_error(&cli).or_else(|| out_is_input(&cli)) {
if let Some(sub) = matches.subcommand_name().and_then(|n| cmd.find_subcommand_mut(n)) {
return Err(e.into_clap(sub));
}
@@ -665,24 +644,9 @@ mod tests {
}
}
/// Without `--connect` the server runs headless, confining nothing unless asked.
#[test]
fn mcp_without_connect_is_headless() {
assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless { read_root: None, write_root: None });
}
/// The automation roots confine a headless server; `--connect` is refused with the reason
/// (the running app's control channel is not confined yet, #1585).
#[test]
fn mcp_automation_roots_confine_a_headless_server_only() {
assert_eq!(
mcp(&["--automation-read-root", "/work", "--automation-write-root=/work/out"]).unwrap(),
McpTarget::Headless { read_root: Some("/work".into()), write_root: Some("/work/out".into()) }
);
let e = mcp(&["--connect", "127.0.0.1:7979", "--automation-read-root", "/work"]).unwrap_err().to_string();
assert!(e.contains("headless MCP server") && e.contains("#1585"), "{e}");
let e = mcp(&["--automation-write-root=/work", "--connect", "127.0.0.1:7979"]).unwrap_err().to_string();
assert!(e.contains("headless MCP server"), "{e}");
assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless);
}
#[test]
-3
View File
@@ -27,9 +27,6 @@ pub(crate) enum CliError {
NotUnicode(std::path::PathBuf),
#[error("cannot connect to {addr}: {source}")]
McpConnect { addr: String, source: std::io::Error },
/// An `--automation-*-root` that cannot be opened (missing, a file, a link that escapes).
#[error("{0}")]
AutomationRoots(String),
}
pub(crate) type Result<T = (), E = CliError> = std::result::Result<T, E>;
+1 -9
View File
@@ -1,7 +1,6 @@
use super::args::{McpArgs, McpTarget};
use super::error::{CliError, Result};
/// Serve MCP on stdin and stdout against the running app or a headless session held to any roots given.
pub(crate) fn mcp(a: &McpArgs) -> Result {
let backend: Box<dyn cadcraft_mcp::Backend> = match a.target() {
McpTarget::Connect { addr, lazy: true, launch } => Box::new(cadcraft_mcp::Remote::lazy(&addr, launch)),
@@ -9,14 +8,7 @@ pub(crate) fn mcp(a: &McpArgs) -> Result {
Ok(r) => Box::new(r),
Err(source) => return Err(CliError::McpConnect { addr, source }),
},
McpTarget::Headless { read_root, write_root } => {
let roots = cadcraft_engine::file_access::AutomationRoots::new(
read_root.as_deref().map(std::path::Path::new),
write_root.as_deref().map(std::path::Path::new),
)
.map_err(CliError::AutomationRoots)?;
Box::new(cadcraft_mcp::Headless::default().with_automation_roots(roots))
}
McpTarget::Headless => Box::new(cadcraft_mcp::Headless::default()),
};
let stdin = std::io::stdin();
let stdout = std::io::stdout();
-404
View File
@@ -1,404 +0,0 @@
//! `cadcraft-cli mcp --automation-read-root <dir> --automation-write-root <dir>` (#1472): through
//! the MCP protocol, files open only from inside the read root and are saved, exported, plotted and
//! rendered only inside the write root; `..` and links that leave a root are refused, and nothing is
//! written outside. Without roots nothing changes.
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Never crash).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Output, Stdio};
use serde_json::{Value, json};
const INIT: &str = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}"#;
/// A folder of a test's own, removed when the test ends, also when it fails.
struct TestDir(PathBuf);
impl std::ops::Deref for TestDir {
type Target = Path;
/// The folder itself.
fn deref(&self) -> &Path {
&self.0
}
}
impl Drop for TestDir {
/// Removes the folder and all it holds; a failure here must not hide the test's own.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder of this test's own: made here, so nothing else put it there first.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cc-mcp-roots-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// A folder holding `in` (the read root, with `a.dxf`), `out` (the write root), `outside` (with
/// `b.dxf`) and `in2` (a sibling with the same prefix as `in`).
fn folders(tag: &str) -> TestDir {
let base = fresh_dir(tag);
for d in ["in", "out", "outside", "in2"] {
std::fs::create_dir_all(base.join(d)).unwrap();
}
for p in ["in/a.dxf", "outside/b.dxf", "in2/c.dxf"] {
let drawing = cadcraft_engine::doc::Drawing::new_imperial();
std::fs::write(base.join(p), cadcraft_io::write(&drawing, "x.dxf").unwrap()).unwrap();
}
base
}
/// `p` as the text a tool call passes.
fn s(p: &Path) -> String {
p.to_string_lossy().into_owned()
}
/// One tool call's result: `isError` and its first text block.
struct Tool {
error: bool,
text: String,
}
/// Run `cadcraft-cli mcp` with `args`, initialise, then make each call in order.
fn run(args: &[&str], calls: &[(&str, Value)]) -> (Output, Vec<Tool>) {
run_env(args, calls, &[])
}
/// [`run`], with `env` set for the server process (a private settings folder).
fn run_env(args: &[&str], calls: &[(&str, Value)], env: &[(&str, &str)]) -> (Output, Vec<Tool>) {
let mut input = format!("{INIT}\n");
for (i, (name, arguments)) in calls.iter().enumerate() {
let req = json!({"jsonrpc": "2.0", "id": i + 2, "method": "tools/call", "params": {"name": name, "arguments": arguments}});
input.push_str(&req.to_string());
input.push('\n');
}
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
.arg("mcp")
.args(args)
.envs(env.iter().copied())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn cadcraft-cli");
if let Some(mut stdin) = child.stdin.take() {
stdin.write_all(input.as_bytes()).unwrap();
}
let out = child.wait_with_output().expect("wait for cadcraft-cli");
let replies: Vec<Value> = String::from_utf8_lossy(&out.stdout).lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
let tools = calls
.iter()
.enumerate()
.map(|(i, (name, arguments))| {
let id = (i + 2) as u64;
let reply = replies.iter().find(|v| v["id"] == id).unwrap_or_else(|| panic!("no reply to {name} {arguments}: {replies:?}"));
assert!(reply.get("error").is_none() && reply["result"].is_object(), "{name} {arguments} got an error reply, not a tool result: {reply}");
let result = &reply["result"];
Tool { error: result["isError"] == true, text: result["content"][0]["text"].as_str().unwrap_or_default().to_string() }
})
.collect();
(out, tools)
}
/// The call succeeded.
fn ok(t: &Tool) {
assert!(!t.error, "should be allowed: {}", t.text);
}
/// The call was refused, saying `why`.
fn refused(t: &Tool, why: &str) {
assert!(t.error, "should be refused ({why}): {}", t.text);
assert!(t.text.contains(why), "should say `{why}`: {}", t.text);
}
/// `open` and every other read stay inside the read root or the write root.
#[test]
fn files_open_only_from_inside_the_read_root() {
let base = folders("open");
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
("open", json!({"path": s(&base.join("outside/b.dxf"))})),
("open", json!({"path": s(&base.join("in2/c.dxf"))})),
("open", json!({"path": format!("{}/../outside/b.dxf", s(&base.join("in")))})),
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
refused(&t[1], "outside the read root");
refused(&t[2], "outside the read root");
refused(&t[3], "outside the read root");
// A refused path is an ordinary tool error; the session keeps working.
ok(&t[4]);
}
/// Writes stay inside the write root, the root itself is refused, and no temporary file is left outside.
#[test]
fn writes_go_only_into_the_write_root_and_leave_no_temp_file_outside() {
let base = folders("write");
let out = s(&base.join("out"));
let (out_run, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &out],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
("save", json!({"path": s(&base.join("out/saved.dxf"))})),
("save", json!({"path": s(&base.join("outside/saved.dxf"))})),
("save", json!({"path": s(&base.join("in/a.dxf"))})),
("save", json!({"path": format!("{}/../outside/up.dxf", s(&base.join("out")))})),
("save", json!({"path": out})),
("save", json!({"path": format!("{out}/../out")})),
("execute", json!({"command": "export", "params": {"path": s(&base.join("out/art.png")), "format": "png"}})),
("execute", json!({"command": "export", "params": {"path": s(&base.join("outside/art.png")), "format": "png"}})),
("render", json!({"path": s(&base.join("out/view.png"))})),
("render", json!({"path": s(&base.join("outside/view.png"))})),
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
],
);
assert!(out_run.status.success(), "stderr: {}", String::from_utf8_lossy(&out_run.stderr));
ok(&t[0]);
ok(&t[1]);
assert!(base.join("out/saved.dxf").is_file());
refused(&t[2], "outside the write root");
refused(&t[3], "outside the write root");
refused(&t[4], "outside the write root");
refused(&t[5], "the write root itself cannot be written");
refused(&t[6], "the write root itself cannot be written");
ok(&t[7]);
assert!(base.join("out/art.png").is_file());
refused(&t[8], "outside the write root");
ok(&t[9]);
assert!(base.join("out/view.png").is_file());
refused(&t[10], "outside the write root");
ok(&t[11]);
assert!(!base.join("outside/saved.dxf").exists());
assert!(!base.join("outside/art.png").exists());
assert!(!base.join("outside/view.png").exists());
// The save's temporary file is beside the destination, inside the root; none is outside.
assert!(!base.join("outside/saved.dxf.cadcraft-tmp").exists());
assert!(!base.join("outside/up.dxf.cadcraft-tmp").exists());
assert!(!base.join("out.cadcraft-tmp").exists(), "writing to the root must not leave its temporary file beside it");
let leftovers: Vec<String> =
std::fs::read_dir(base.join("outside")).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
assert_eq!(leftovers, ["b.dxf"], "nothing was written outside the roots");
let temps: Vec<String> =
std::fs::read_dir(&*base).unwrap().filter_map(|e| e.ok()?.file_name().into_string().ok()).filter(|n| n.ends_with(".cadcraft-tmp")).collect();
assert!(temps.is_empty(), "no temporary file beside or outside the roots: {temps:?}");
}
/// A root left out grants none of its own access: a read root allows no writes, while a write root also allows reads.
#[test]
fn a_root_left_out_grants_none_of_its_access() {
let base = folders("left-out");
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in"))],
&[("open", json!({"path": s(&base.join("in/a.dxf"))})), ("save", json!({"path": s(&base.join("out/a.dxf"))})), ("save", json!({}))],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
refused(&t[1], "write authority is absent");
// QSAVE writes over the opened drawing's own path, which is not writable either.
refused(&t[2], "write authority is absent");
let (out, t) = run(
&["--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
("save", json!({"path": s(&base.join("out/new.dxf"))})),
// Reads are allowed under the write root: the agent can reopen what it saved.
("open", json!({"path": s(&base.join("out/new.dxf"))})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
refused(&t[0], "outside the read root (or the write root)");
ok(&t[1]);
assert!(base.join("out/new.dxf").is_file());
ok(&t[2]);
}
/// The shared plotter settings folder is outside the roots: every action refuses and it is unchanged.
#[test]
fn plotter_settings_outside_the_roots_are_refused() {
let base = folders("plotters");
let config = base.join("config");
let settings = config.join("plotters");
std::fs::create_dir_all(&settings).unwrap();
let device = cadcraft_engine::doc::PlotterConfig {
name: "Office".into(),
description: "not the agent's".into(),
papers: vec![cadcraft_engine::doc::DevicePaper { name: "A4".into(), width: 210.0, height: 297.0, margins: [5.0; 4] }],
..Default::default()
};
let file = settings.join("Office.plotter.json");
let original = device.to_file_text();
std::fs::write(&file, &original).unwrap();
let text = original.clone();
let (out, t) = run_env(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("execute", json!({"command": "plottermanager", "params": {}})),
("execute", json!({"command": "plottermanager", "params": {"action": "get", "name": "Office"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "new", "name": "Leak", "output": "pdf"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "set", "name": "Office", "description": "changed"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "load", "text": text, "name": "Leaked Copy"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "delete", "name": "Office"}})),
],
&[("CADCRAFT_CONFIG_DIR", &s(&config))],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
refused(&t[0], "outside the read root (or the write root)");
refused(&t[1], "unknown plotter");
refused(&t[2], "outside the write root");
refused(&t[3], "unknown plotter");
refused(&t[4], "outside the write root");
refused(&t[5], "unknown plotter");
assert_eq!(std::fs::read_to_string(&file).unwrap(), original, "the shared file is unchanged");
let names: Vec<String> = std::fs::read_dir(&settings).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
assert_eq!(names, ["Office.plotter.json"], "nothing was created or deleted in the settings folder");
assert!(!settings.join("Office.plotter.json.cadcraft-tmp").exists());
}
/// With no roots nothing changes: files anywhere can be reached.
#[test]
fn without_roots_files_are_reachable_as_before() {
let base = folders("none");
let (out, t) =
run(&[], &[("open", json!({"path": s(&base.join("outside/b.dxf"))})), ("save", json!({"path": s(&base.join("outside/new.dxf"))}))]);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
ok(&t[1]);
assert!(base.join("outside/new.dxf").is_file());
}
/// A link inside a root leading out is refused for reads and writes.
#[cfg(unix)]
#[test]
fn links_out_of_a_root_are_refused() {
let base = folders("links");
std::os::unix::fs::symlink(base.join("outside"), base.join("out/away")).unwrap();
std::os::unix::fs::symlink(base.join("outside/b.dxf"), base.join("in/leak.dxf")).unwrap();
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[("open", json!({"path": s(&base.join("in/leak.dxf"))})), ("save", json!({"path": s(&base.join("out/away/new.dxf"))}))],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
refused(&t[0], "outside the read root");
refused(&t[1], "outside the write root");
assert!(!base.join("outside/new.dxf").exists());
}
/// Each kind of command that touches a file is refused outside the roots.
#[test]
fn every_file_a_command_touches_is_held_to_the_roots() {
let base = folders("commands");
let drawing = cadcraft_engine::doc::Drawing::new_imperial();
std::fs::write(base.join("in/x.dxf"), cadcraft_io::write(&drawing, "x.dxf").unwrap()).unwrap();
std::fs::write(base.join("in/ok.scr"), "CIRCLE 0,0 1\n").unwrap();
std::fs::write(base.join("outside/bad.scr"), "CIRCLE 0,0 1\n").unwrap();
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
// SCRIPT
("execute", json!({"command": "script", "params": {"path": s(&base.join("in/ok.scr"))}})),
("execute", json!({"command": "script", "params": {"path": s(&base.join("outside/bad.scr"))}})),
// XATTACH reads the referenced drawing, INSERT and IMPORT read their files.
("execute", json!({"command": "xattach", "params": {"path": s(&base.join("in/x.dxf")), "name": "ok"}})),
("execute", json!({"command": "xattach", "params": {"path": s(&base.join("outside/b.dxf")), "name": "bad"}})),
("execute", json!({"command": "insert", "params": {"name": "blk", "file": s(&base.join("outside/b.dxf")), "at": [0, 0]}})),
("execute", json!({"command": "import", "params": {"path": s(&base.join("outside/b.dxf"))}})),
// Support files (a linetype file here) and a plot style table.
("execute", json!({"command": "linetype", "params": {"file": s(&base.join("outside/b.dxf"))}})),
("execute", json!({"command": "stylesmanager", "params": {"action": "load", "path": s(&base.join("outside/b.dxf"))}})),
// PLOT writes only inside the write root; the inside plot works.
("execute", json!({"command": "plot", "params": {"path": s(&base.join("out/plot.pdf"))}})),
("execute", json!({"command": "plot", "params": {"path": s(&base.join("outside/plot.pdf"))}})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
ok(&t[1]);
refused(&t[2], "outside the read root");
ok(&t[3]);
refused(&t[4], "outside the read root");
refused(&t[5], "outside the read root");
refused(&t[6], "outside the read root");
refused(&t[7], "outside the read root");
refused(&t[8], "outside the read root");
ok(&t[9]);
assert!(base.join("out/plot.pdf").is_file());
refused(&t[10], "outside the write root");
assert!(!base.join("outside/plot.pdf").exists());
}
/// A root that can't be opened, or roots with `--connect`, stop the server at startup.
#[test]
fn missing_roots_and_roots_with_connect_fail_at_startup() {
let base = folders("bad-roots");
let input = format!("{INIT}\n");
let start = |args: &[&str]| {
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
.arg("mcp")
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn cadcraft-cli");
if let Some(mut stdin) = child.stdin.take() {
let _ = stdin.write_all(input.as_bytes());
}
child.wait_with_output().expect("wait for cadcraft-cli")
};
let out = start(&["--automation-read-root", &s(&base.join("nope"))]);
assert!(!out.status.success() && out.stdout.is_empty());
assert!(String::from_utf8_lossy(&out.stderr).contains("cannot open the automation read root"));
let out = start(&["--automation-write-root", &s(&base.join("in/a.dxf"))]);
assert!(!out.status.success() && out.stdout.is_empty());
assert!(String::from_utf8_lossy(&out.stderr).contains("cannot open the automation write root"));
let out = start(&["--connect", "127.0.0.1:1", "--automation-read-root", &s(&base.join("in"))]);
assert!(!out.status.success() && out.stdout.is_empty());
assert!(String::from_utf8_lossy(&out.stderr).contains("headless MCP server"));
}
/// A UNC, device or non-disk verbatim path is refused by the server before it is opened.
/// The reply names the prefix. It is not an operating-system error from opening the path.
#[cfg(windows)]
#[test]
fn a_network_path_is_refused_before_it_is_opened() {
let base = folders("unc");
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": r"\\203.0.113.5\s\x.dwg"})),
("open", json!({"path": r"\\?\UNC\203.0.113.5\s\x.dwg"})),
("open", json!({"path": r"\\host@SSL\share\x.dwg"})),
("open", json!({"path": r"\\.\PhysicalDrive0"})),
("open", json!({"path": r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x.dwg"})),
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
let kinds = ["UNC", "UNC", "UNC", "device path", "verbatim path"];
for (tool, kind) in t.iter().zip(kinds) {
refused(tool, kind);
assert!(!tool.text.contains("cannot resolve") && !tool.text.to_ascii_lowercase().contains("os error"), "{}", tool.text);
}
ok(&t[5]);
}
-749
View File
@@ -1,749 +0,0 @@
//! Walks every command in the registry through the real MCP server with paths outside the
//! automation roots (#1472). Reads show as a changed access time and writes as a changed size or
//! modification time, a removed file, or a file that was not there before, whatever the command
//! does with the path. The same walk without roots has to find escapes, or finding none under
//! roots would prove nothing.
#![cfg(unix)]
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Never crash).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::{BTreeMap, BTreeSet};
use std::fs::{File, FileTimes};
use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};
use std::process::{Child, ChildStdin, Command, Stdio};
use std::sync::mpsc::{Receiver, channel};
use std::time::{Duration, SystemTime};
use serde_json::{Value, json};
/// Longest a call may take before the server counts as hung.
const CALL_TIMEOUT: Duration = Duration::from_secs(60);
/// The extensions commands choose their behaviour by.
const EXTENSIONS: &[&str] = &["dxf", "dwg", "dwt", "scr", "lsp", "lin", "pat", "pgp", "csv", "txt", "png", "pdf", "svg", "ctb"];
/// The parameter names a command might take a path under.
const PATH_KEYS: &[&str] =
&["path", "file", "template", "patternFile", "from", "to", "source", "target", "output", "folder", "dir", "filename", "document"];
/// A valid 1x1 PNG.
const PNG: &[u8] = &[
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0, 0x0D, 0x49, 0x48, 0x44, 0x52, 0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 0x1F, 0x15, 0xC4,
0x89, 0, 0, 0, 0x0A, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0, 1, 0, 0, 5, 0, 1, 0x0D, 0x0A, 0x2D, 0xB4, 0, 0, 0, 0, 0x49, 0x45, 0x4E, 0x44,
0xAE, 0x42, 0x60, 0x82,
];
/// `p` as the text a tool call passes.
fn s(p: &Path) -> String {
p.to_string_lossy().into_owned()
}
/// A running `cadcraft-cli mcp`.
struct Server {
child: Child,
stdin: ChildStdin,
replies: Receiver<Value>,
next: u64,
}
impl Server {
/// Start the real binary as an MCP server and initialize it.
fn start(args: &[String], cwd: &Path, config: &Path) -> Self {
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
.arg("mcp")
.args(args)
.current_dir(cwd)
.env("CADCRAFT_CONFIG_DIR", config)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()
.expect("spawn cadcraft-cli");
let stdin = child.stdin.take().unwrap();
let stdout = child.stdout.take().unwrap();
let (tx, replies) = channel();
std::thread::spawn(move || {
for line in BufReader::new(stdout).lines().map_while(Result::ok) {
if let Ok(v) = serde_json::from_str::<Value>(&line)
&& tx.send(v).is_err()
{
break;
}
}
});
let mut server = Self { child, stdin, replies, next: 1 };
server.request("initialize", json!({"protocolVersion": "2025-06-18"})).expect("initialize");
server
}
/// Send one JSON-RPC request; `None` if the server stopped answering.
fn request(&mut self, method: &str, params: Value) -> Option<Value> {
let id = self.next;
self.next += 1;
let req = json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params});
writeln!(self.stdin, "{req}").ok()?;
loop {
let reply = self.replies.recv_timeout(CALL_TIMEOUT).ok()?;
if reply["id"] == id {
return Some(reply);
}
}
}
/// A tool's first text block, or `None` when the server hung or stopped.
fn tool(&mut self, name: &str, arguments: Value) -> Option<String> {
let reply = self.request("tools/call", json!({"name": name, "arguments": arguments}))?;
Some(reply["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string())
}
/// Like [`Self::tool`] for a call that must work: an error reply, or a result flagged as an
/// error, fails the test.
fn tool_ok(&mut self, name: &str, arguments: Value) -> String {
let reply = self.request("tools/call", json!({"name": name, "arguments": arguments})).expect("the server answered");
assert!(reply.get("error").is_none() && reply["result"]["isError"] != true, "{name} should have worked: {reply}");
reply["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string()
}
/// Run an engine command through the `execute` tool.
fn execute(&mut self, command: &str, params: Value) -> Option<String> {
self.tool("execute", json!({"command": command, "params": params}))
}
}
impl Drop for Server {
/// Stops the server it started.
fn drop(&mut self) {
let _ = self.child.kill();
let _ = self.child.wait();
}
}
/// The folders of one walk: `in` and `out` are the roots, nothing under `outside` may be touched.
/// A new folder of this test's own: made here, so nothing else put it there first.
fn fresh_dir(tag: &str) -> PathBuf {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cc-walk-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return dir,
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// Remove the file or folder at `p`.
fn remove(p: &Path) {
let _ = if p.is_dir() { std::fs::remove_dir_all(p) } else { std::fs::remove_file(p) };
}
/// Remove what `dir` holds, if it exists.
fn clear(dir: &Path) {
for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() {
remove(&entry.path());
}
}
struct Fixture {
base: PathBuf,
outside: PathBuf,
/// Each path under `outside`, with its size, modification time and access time.
baseline: BTreeMap<PathBuf, (u64, SystemTime, SystemTime)>,
/// Whether this file system records reads at all (`noatime` doesn't).
sees_reads: bool,
}
impl Fixture {
/// A new fixture, finding out whether this file system records reads.
fn new(tag: &str) -> Self {
let base = fresh_dir(tag);
for d in ["in", "out"] {
std::fs::create_dir(base.join(d)).unwrap();
}
let probe = base.join("probe");
std::fs::write(&probe, "x").unwrap();
age_access_time(&probe);
let before = std::fs::metadata(&probe).unwrap().accessed().unwrap();
std::fs::read(&probe).unwrap();
let sees_reads = std::fs::metadata(&probe).unwrap().accessed().unwrap() != before;
let outside = base.join("outside");
let mut f = Self { base, outside, baseline: BTreeMap::new(), sees_reads };
f.reset();
f
}
/// Lay out `outside` afresh and start watching it.
fn reset(&mut self) {
let o = self.outside.clone();
// The running server's working directory stays: without it a relative path can't be resolved.
clear(&o.join("cwd"));
for entry in std::fs::read_dir(&o).into_iter().flatten().flatten() {
if entry.file_name() != "cwd" {
remove(&entry.path());
}
}
for d in ["cwd", "config/plotters", "recover"] {
std::fs::create_dir_all(o.join(d)).unwrap();
}
let dxf = cadcraft_io::write(&cadcraft_engine::doc::Drawing::new_imperial(), "x.dxf").unwrap();
for ext in EXTENSIONS {
let body: &[u8] = match *ext {
"dxf" | "dwg" | "dwt" => &dxf,
"scr" => b"CIRCLE 0,0 5\n",
"lsp" => b"(princ 1)\n",
"lin" => b"*WALK,walk\nA,1,-1\n",
"pat" => b"*WALK,walk\n0,0,0,0,1\n",
"pgp" => b"W,*LINE\n",
"csv" | "txt" => b"a,b\n1,2\n",
"png" => PNG,
_ => b"canary",
};
std::fs::write(o.join(format!("canary.{ext}")), body).unwrap();
}
// Two images, so that a drawing naming both loads them on threads of their own.
std::fs::write(o.join("second.png"), PNG).unwrap();
let device = cadcraft_engine::doc::PlotterConfig { name: "Office".into(), ..Default::default() };
std::fs::write(o.join("config/plotters/Office.plotter.json"), device.to_file_text()).unwrap();
self.watch();
}
/// Start watching what is under `outside` now.
fn watch(&mut self) {
let o = self.outside.clone();
self.baseline.clear();
for p in tree(&o) {
age_access_time(&p);
let m = std::fs::metadata(&p).unwrap();
self.baseline.insert(p, (m.len(), m.modified().unwrap(), m.accessed().unwrap()));
}
}
/// What happened under `outside` since [`Self::reset`]. Metadata is read before any directory
/// listing, and directory access times are put back afterwards: the listing is how a new file
/// is seen when the folder's modification time has not moved, and it must not look like a read.
fn touched(&self) -> Vec<String> {
let mut seen = Vec::new();
for (p, (len, modified, accessed)) in &self.baseline {
let name = p.strip_prefix(&self.outside).unwrap_or(p).display();
match std::fs::metadata(p) {
Err(_) => seen.push(format!("removed {name}")),
Ok(m) if m.modified().unwrap() != *modified || (!m.is_dir() && m.len() != *len) => seen.push(format!("wrote {name}")),
Ok(m) if self.sees_reads && m.accessed().unwrap() != *accessed => seen.push(format!("read {name}")),
Ok(_) => {}
}
}
for p in tree(&self.outside) {
if !self.baseline.contains_key(&p) {
let name = p.strip_prefix(&self.outside).unwrap_or(&p).display();
seen.push(format!("created {name}"));
}
}
for (p, (_, _, accessed)) in &self.baseline {
if p.is_dir() {
let _ = File::open(p).and_then(|f| f.set_times(FileTimes::new().set_accessed(*accessed)));
}
}
seen
}
}
impl Drop for Fixture {
/// Removes the fixture folder when the test ends, also when it fails.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.base);
}
}
/// Every file and folder under `dir`.
fn tree(dir: &Path) -> Vec<PathBuf> {
let mut out = vec![dir.to_path_buf()];
for e in std::fs::read_dir(dir).unwrap().flatten() {
if e.path().is_dir() {
out.extend(tree(&e.path()));
} else {
out.push(e.path());
}
}
out
}
/// Put `p`'s access time in the past, so that the next read updates it even under `relatime`.
fn age_access_time(p: &Path) {
let past = SystemTime::now() - Duration::from_secs(3 * 24 * 3600);
File::open(p).unwrap().set_times(FileTimes::new().set_accessed(past)).unwrap();
}
/// The `action` or `option` values a parameter doc lists: `action?: list|open|discard (…)`.
fn actions(doc: &str) -> Vec<String> {
let mut out = Vec::new();
for key in ["action", "option"] {
let Some(at) = doc.find(key) else { continue };
let rest = doc[at + key.len()..].trim_start_matches(['?', ':', ' ']);
let end = rest.find([',', '}', '(']).unwrap_or(rest.len());
out.extend(rest[..end].split('|').map(|w| w.trim().trim_matches('"').to_string()).filter(|w| !w.is_empty()));
}
out
}
/// The calls to try for command `id`: every path-like key set to `target`, with each action.
fn variants(doc: &str, target: &str, handle: &str, table: &str) -> Vec<Value> {
let mut base = json!({"handle": table, "handles": [handle], "at": [0, 0], "name": "walk"});
for key in PATH_KEYS {
base[*key] = json!(target);
}
let mut named = base.clone();
named["name"] = json!(target);
let mut device = base.clone();
device["name"] = json!("Office");
// Commands refuse parameters that don't go together, so each key the doc names goes on its own too.
let lower = doc.to_ascii_lowercase();
let documented = PATH_KEYS.iter().filter(|key| **key == "path" || lower.contains(&key.to_ascii_lowercase()));
let alone = documented.flat_map(|key| {
[
json!({*key: target}),
json!({*key: target, "handles": [handle]}),
json!({*key: target, "handle": table}),
json!({*key: target, "name": "Office"}),
]
});
let mut out = Vec::new();
for v in [base, named, device].into_iter().chain(alone) {
out.push(v.clone());
for a in actions(doc) {
let mut with = v.clone();
with["action"] = json!(a);
with["option"] = json!(a);
out.push(with);
}
}
out
}
/// Whether a command's doc says it takes a file. These get every extension; the rest, one.
fn takes_a_file(doc: &str) -> bool {
let d = doc.to_ascii_lowercase();
["path", "file", "template", "folder", "action", "option"].iter().any(|w| d.contains(w))
}
/// A fresh drawing with a circle and a table, selected; the circle's and table's handles.
fn seed(server: &mut Server) -> Option<(String, String)> {
// Closed first: the walk starts tens of thousands of drawings, and they would all stay open.
server.execute("closeall", json!({}))?;
server.execute("new", json!({}))?;
let handle_of = |text: &str| serde_json::from_str::<Value>(text).ok().and_then(|v| v["handle"].as_str().map(str::to_string)).unwrap_or_default();
let circle = server.execute("circle", json!({"center": [0, 0], "radius": 1}))?;
let table = server.execute("table", json!({"at": [5, 5], "rows": 2, "columns": 2}))?;
server.execute("selectall", json!({}))?;
Some((handle_of(&circle), handle_of(&table)))
}
/// What one walk saw.
struct Walk {
/// The command and the call that touched each file outside.
escapes: BTreeMap<String, Vec<String>>,
calls: usize,
commands: usize,
/// Calls that hung or stopped the server.
lost: Vec<String>,
sees_reads: bool,
}
/// Run the walk, under `in` and `out` as roots or with no roots at all.
fn walk(tag: &str, roots: bool) -> Walk {
let mut f = Fixture::new(tag);
let args = if roots {
vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))]
} else {
vec![]
};
let cwd = f.outside.join("cwd");
let config = f.outside.join("config");
let start = |f: &mut Fixture| {
let server = Server::start(&args, &cwd, &config);
f.reset();
server
};
let mut server = start(&mut f);
let listed = server.tool("list_commands", json!({})).expect("list_commands");
let specs: Vec<Value> = serde_json::from_str(&listed).expect("the command list");
assert!(specs.len() > 400, "the walk has to see the registry: {} commands", specs.len());
let mut result = Walk { escapes: BTreeMap::new(), calls: 0, commands: specs.len(), lost: Vec::new(), sees_reads: f.sees_reads };
let mut steps: Vec<(String, Value)> = Vec::new();
let o = f.outside.clone();
let canary = |ext: &str| s(&o.join(format!("canary.{ext}")));
let (circle, table) = seed(&mut server).expect("seed");
assert!(!circle.is_empty(), "the seed circle has no handle");
assert!(!table.is_empty(), "the seed table has no handle");
for spec in &specs {
let id = spec["id"].as_str().unwrap().to_string();
let doc = spec["params"].as_str().unwrap_or_default();
let mut targets: Vec<String> = if takes_a_file(doc) { EXTENSIONS.iter().map(|e| canary(e)).collect() } else { vec![canary("dxf")] };
if takes_a_file(doc) {
// A file that isn't there yet, in a folder that isn't there yet, and a relative path.
targets.extend(["dxf", "png", "pdf", "csv"].iter().map(|e| s(&o.join(format!("fresh/x.{e}")))));
targets.push("../canary.dxf".to_string());
}
for target in targets {
for v in variants(doc, &target, &circle, &table) {
steps.push((id.clone(), v));
}
}
}
let run_step =
|server: &mut Server, f: &mut Fixture, result: &mut Walk, id: &str, label: String, call: &mut dyn FnMut(&mut Server) -> Option<String>| {
result.calls += 1;
let done = call(server);
let touched = f.touched();
if !touched.is_empty() {
for what in touched {
result.escapes.entry(id.to_string()).or_default().push(format!("{what}: {label}"));
}
}
if done.is_none() {
result.lost.push(format!("{id}: {label}"));
}
done.is_some()
};
for (id, params) in &steps {
let label = params.to_string();
let params = params.clone();
let alive = run_step(&mut server, &mut f, &mut result, id, label, &mut |sv| sv.execute(id, params.clone()));
let dirty = !f.touched().is_empty();
if !alive {
server = start(&mut f);
} else if dirty {
f.reset();
}
// A command can stop the server without its own reply being lost.
if seed(&mut server).is_none() {
result.lost.push(format!("after {id}: {params}"));
server = start(&mut f);
seed(&mut server);
}
}
// The ways in that aren't one command with a path parameter.
let dxf = canary("dxf");
let png = canary("png");
let scr = canary("scr");
let lsp = canary("lsp");
let tools: Vec<(&str, &str, Value)> = vec![
("tool:open", "open", json!({"path": dxf})),
("tool:save", "save", json!({"path": dxf})),
("tool:save-new", "save", json!({"path": s(&o.join("fresh/y.dxf"))})),
("tool:render", "render", json!({"path": png})),
("tool:command_line", "command_line", json!({"text": format!("SCRIPT {scr}")})),
("tool:command_line", "command_line", json!({"text": format!("OPEN {dxf}")})),
("tool:command_line", "command_line", json!({"text": format!("SAVEAS {dxf}")})),
("tool:script", "script", json!({"text": format!("OPEN {dxf}\n")})),
];
for (label, name, a) in tools {
let text = a.to_string();
let a = a.clone();
let alive = run_step(&mut server, &mut f, &mut result, label, text, &mut |sv| sv.tool(name, a.clone()));
if alive {
f.reset();
} else {
server = start(&mut f);
}
seed(&mut server);
}
let lisp = [
format!("(setq f (open {dxf:?} \"r\")) (read-line f) (close f)"),
format!("(setq f (open {dxf:?} \"w\")) (write-line \"x\" f) (close f)"),
format!("(setq f (open {:?} \"w\")) (write-line \"x\" f) (close f)", s(&o.join("new.txt"))),
format!("(load {lsp:?})"),
];
for code in lisp {
let label = code.clone();
run_step(&mut server, &mut f, &mut result, "lisp:code", label, &mut |sv| sv.execute("lisp", json!({"code": code})));
f.reset();
seed(&mut server);
}
// Settings that name a file or a folder, then the commands that use them.
let chained: Vec<(&str, Vec<(&str, Value)>)> = vec![
(
"stylesmanager",
vec![
("stylesmanager", json!({"action": "new", "name": "walk.ctb"})),
("stylesmanager", json!({"action": "save", "name": "walk.ctb", "path": canary("ctb")})),
("stylesmanager", json!({"action": "load", "path": canary("ctb")})),
],
),
(
"pdfbook",
vec![("pline", json!({"points": [[0, 0], [210, 0], [210, 297], [0, 297]], "closed": true})), ("pdfbook", json!({"path": canary("pdf")}))],
),
("setvar:SAVEFILEPATH", vec![("setvar", json!({"name": "SAVEFILEPATH", "value": s(&o.join("recover"))})), ("drawingrecovery", json!({}))]),
("setvar:QNEWTEMPLATE", vec![("setvar", json!({"name": "QNEWTEMPLATE", "value": dxf})), ("new", json!({}))]),
];
for (label, calls) in chained {
for (id, params) in calls {
run_step(&mut server, &mut f, &mut result, label, format!("{id} {params}"), &mut |sv| sv.execute(id, params.clone()));
}
f.reset();
seed(&mut server);
}
result
}
/// One line saying what a walk saw.
fn summary(w: &Walk) -> String {
format!(
"{} commands, {} calls, reads seen: {}, {} commands touched files outside, {} calls lost the server",
w.commands,
w.calls,
w.sees_reads,
w.escapes.len(),
w.lost.len()
)
}
/// Under roots, nothing in the registry reaches a file outside them.
#[test]
fn no_command_escapes_the_roots() {
let w = walk("roots", true);
println!("under roots: {}", summary(&w));
let found: Vec<String> = w.escapes.iter().flat_map(|(id, what)| what.iter().take(3).map(move |l| format!("{id}: {l}"))).collect();
assert!(found.is_empty(), "escapes under the roots:\n{}", found.join("\n"));
assert!(w.lost.is_empty(), "calls that lost the server: {:?}", w.lost);
}
/// The control: without roots the same walk finds these commands reaching the same files. If this
/// fails, the walk has stopped reaching them and [`no_command_escapes_the_roots`] proves nothing.
#[test]
fn the_walk_finds_escapes_without_roots() {
let w = walk("control", false);
println!("without roots: {}", summary(&w));
let found: BTreeSet<&str> = w.escapes.keys().map(String::as_str).collect();
println!("touched files outside: {}", found.iter().copied().collect::<Vec<_>>().join(" "));
let writers = [
"saveas",
"export",
"plot",
"exportpdf",
"publish",
"pdfbook",
"wblock",
"-wblock",
"layout.saveas",
"layout",
"stylesmanager",
"tableexport",
"dataextraction",
"tool:save",
"tool:save-new",
"tool:render",
"lisp:code",
];
// What a command touched is kept with its kind (`wrote`, `created`, `removed`, `read`): a writer
// must show a write, not just a read, or a writer that only reads would still pass.
let kinds = |id: &str, kinds: &[&str]| w.escapes.get(id).is_some_and(|e| e.iter().any(|l| kinds.iter().any(|k| l.starts_with(k))));
let not_writing: Vec<&str> = writers.into_iter().filter(|id| !kinds(id, &["wrote ", "created ", "removed "])).collect();
assert!(not_writing.is_empty(), "the walk no longer finds these writing outside: {not_writing:?}; touched: {:?}", w.escapes);
if w.sees_reads {
for id in [
"open",
"new",
"recover",
"script",
"import",
"insert",
"minsert",
"xattach",
"-xref",
"compare",
"imageattach",
"attach",
"aliasedit",
"linetype",
"hatch.patterns",
"plottermanager",
"appload",
"datalink",
"tool:open",
"setvar:QNEWTEMPLATE",
"setvar:SAVEFILEPATH",
] {
assert!(kinds(id, &["read "]), "the walk no longer finds `{id}` reading outside: {found:?}");
}
}
}
/// A drawing inside the roots can't bring in what it names outside them: an image or an xref saved
/// with a path outside stays unloaded, and nothing outside is read.
#[test]
fn a_drawing_cannot_reach_files_it_names_outside_the_roots() {
let mut f = Fixture::new("named");
let host = f.base.join("in/host.dxf");
{
// Made without roots: a drawing someone hands the agent.
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
let image = free.execute("imageattach", json!({"path": s(&f.outside.join("canary.png"))})).unwrap();
assert!(image.contains("handle"), "the image attaches: {image}");
let second = free.execute("imageattach", json!({"path": s(&f.outside.join("second.png"))})).unwrap();
assert!(second.contains("handle"), "the second image attaches: {second}");
let xref = free.execute("xattach", json!({"path": s(&f.outside.join("canary.dxf")), "name": "walk"})).unwrap();
assert!(xref.contains("handle"), "the xref attaches: {xref}");
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
let opened = server.tool("open", json!({"path": s(&host)})).unwrap();
let images = server.execute("image", json!({})).unwrap();
let xrefs = server.execute("xref", json!({})).unwrap();
server.tool_ok("render", json!({}));
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}\nopen: {opened}\nimage: {images}\nxref: {xrefs}");
assert!(images.contains("canary.png") && !images.contains("\"Loaded\""), "the image stays unloaded: {images}");
assert!(images.contains("\"foundAt\": null") || images.contains("\"foundAt\":null"), "and it isn't said to exist: {images}");
assert!(!xrefs.contains("\"Loaded\""), "the xref stays unloaded: {xrefs}");
}
/// A font linked into the drawing's folder isn't read from where the link leads.
#[test]
fn a_font_linked_beside_a_drawing_is_not_followed_out() {
let mut f = Fixture::new("font");
let host = f.base.join("in/host.dxf");
{
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
free.execute("style", json!({"name": "Walk", "font": "walkfont.shx"})).unwrap();
free.execute("style.current", json!({"name": "Walk"})).unwrap();
let text = free.execute("text", json!({"at": [0, 0], "height": 5, "text": "walk"})).unwrap();
assert!(text.contains("handle"), "the text is drawn: {text}");
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let saved = std::fs::read_to_string(&host).unwrap();
assert!(saved.to_ascii_lowercase().contains("walkfont.shx"), "the drawing names the font");
std::fs::write(f.outside.join("walkfont.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
std::os::unix::fs::symlink(f.outside.join("walkfont.shx"), f.base.join("in/walkfont.shx")).unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
std::fs::write(f.outside.join("walkfont.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
f.watch();
server.tool_ok("open", json!({"path": s(&host)}));
server.tool_ok("render", json!({}));
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}");
}
/// Saving through a link that stands outside the roots and points in doesn't leave a backup
/// beside the link.
#[test]
fn a_backup_stays_inside_the_roots() {
let f = Fixture::new("backup");
let target = f.base.join("out/t.dxf");
std::fs::write(&target, cadcraft_io::write(&cadcraft_engine::doc::Drawing::new_imperial(), "x.dxf").unwrap()).unwrap();
let link = f.outside.join("link.dxf");
std::os::unix::fs::symlink(&target, &link).unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
server.tool("new_drawing", json!({})).unwrap();
let saved = server.tool("save", json!({"path": s(&link)})).unwrap();
assert!(saved.contains("outside the write root"), "{saved}");
assert!(!f.outside.join("link.dxf.bak").exists() && !f.outside.join("link.bak").exists(), "{saved}");
}
/// Deleting a plotter acts on the entry in the settings folder, whatever it points at.
#[test]
fn a_plotter_link_outside_the_roots_is_not_removed() {
let f = Fixture::new("plotter");
let inside = f.base.join("out/kept.plotter.json");
std::fs::write(&inside, cadcraft_engine::doc::PlotterConfig { name: "Kept".into(), ..Default::default() }.to_file_text()).unwrap();
let entry = f.outside.join("config/plotters/Kept.plotter.json");
std::os::unix::fs::symlink(&inside, &entry).unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
let reply = server.execute("plottermanager", json!({"action": "delete", "name": "Kept"})).unwrap();
assert!(std::fs::symlink_metadata(&entry).is_ok(), "the link is still there: {reply}");
}
/// Without roots, a settings folder that can't be read leaves the built-in devices listed.
#[test]
fn without_roots_an_unreadable_settings_folder_still_lists_devices() {
let f = Fixture::new("devices");
let not_a_folder = f.outside.join("canary.txt");
let mut server = Server::start(&[], &f.outside.join("cwd"), &not_a_folder);
let list = server.execute("plottermanager", json!({"action": "list"})).unwrap();
assert!(list.contains("devices"), "{list}");
}
/// A font beside a drawing inside the roots is still used.
#[test]
fn a_font_beside_a_drawing_inside_the_roots_is_used() {
let f = Fixture::new("font-inside");
let host = f.base.join("in/host.dxf");
{
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
free.execute("style", json!({"name": "Walk", "font": "walkinside.shx"})).unwrap();
free.execute("style.current", json!({"name": "Walk"})).unwrap();
free.execute("text", json!({"at": [0, 0], "height": 5, "text": "walk"})).unwrap();
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let font = f.base.join("in/walkinside.shx");
std::fs::write(&font, b"AutoCAD-86 shapes 1.0").unwrap();
age_access_time(&font);
let before = std::fs::metadata(&font).unwrap().accessed().unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
server.tool_ok("open", json!({"path": s(&host)}));
server.tool_ok("render", json!({}));
if f.sees_reads {
assert_ne!(std::fs::metadata(&font).unwrap().accessed().unwrap(), before, "the font was read");
}
}
/// One font that is a link leading out doesn't cost the drawing the other fonts beside it, and
/// nothing outside is touched.
#[test]
fn a_font_link_leading_out_does_not_cost_the_fonts_beside_it() {
let mut f = Fixture::new("font-mixed");
let host = f.base.join("in/host.dxf");
{
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
for (style, font) in [("Good", "walkgood.shx"), ("Bad", "walkbad.shx")] {
free.execute("style", json!({"name": style, "font": font})).unwrap();
free.execute("style.current", json!({"name": style})).unwrap();
free.execute("text", json!({"at": [0, 0], "height": 5, "text": style})).unwrap();
}
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let good = f.base.join("in/walkgood.shx");
std::fs::write(&good, b"AutoCAD-86 shapes 1.0").unwrap();
age_access_time(&good);
let before = std::fs::metadata(&good).unwrap().accessed().unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
std::fs::write(f.outside.join("walkbad.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
std::os::unix::fs::symlink(f.outside.join("walkbad.shx"), f.base.join("in/walkbad.shx")).unwrap();
f.watch();
server.tool_ok("open", json!({"path": s(&host)}));
server.tool_ok("render", json!({}));
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}");
if f.sees_reads {
assert_ne!(std::fs::metadata(&good).unwrap().accessed().unwrap(), before, "the good font was read");
}
}
/// The fixture leaves the server's working directory in place, so a relative path meets the roots
/// and not a folder that has gone.
#[test]
fn a_relative_path_is_refused_by_the_roots() {
let mut f = Fixture::new("relative");
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
let reply = server.tool("open", json!({"path": "../canary.dxf"})).unwrap();
assert!(reply.contains("outside the read root"), "{reply}");
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}");
}
-2
View File
@@ -20,8 +20,6 @@ cadcraft-mcp = { workspace = true }
eframe = { workspace = true, features = ["clipboard", "wgpu", "accesskit", "wayland", "x11", "links", "persistence"] }
egui = { workspace = true }
serde_json = { workspace = true }
# The control request parser reads only its own keys (control_server.rs `Fields`).
serde = { workspace = true }
log = { workspace = true }
clap = { workspace = true }
thiserror = { workspace = true }
+15 -116
View File
@@ -221,17 +221,12 @@ fn read_bounded_line(reader: &mut impl BufRead, buf: &mut Vec<u8>, max: usize, h
}
}
/// Longest request `id` (it is copied into the reply).
const MAX_ID_BYTES: usize = 4096;
/// One request line, parsed.
enum Line<'a> {
enum Line {
Request {
id: Value,
method: String,
/// Left as text until the token is checked: decoding it first would let an unauthenticated
/// peer turn a flat array into many owned JSON values.
params: Option<&'a serde_json::value::RawValue>,
params: Value,
token: Option<String>,
},
Blank,
@@ -240,7 +235,7 @@ enum Line<'a> {
}
/// Parse a UTF-8 JSON request and its optional token, distinguishing blank lines from rejected input.
fn parse_line(bytes: &[u8]) -> Line<'_> {
fn parse_line(bytes: &[u8]) -> Line {
let Ok(text) = std::str::from_utf8(bytes) else {
return Line::Reject("not a control request (invalid UTF-8); closing the connection".into());
};
@@ -251,78 +246,22 @@ fn parse_line(bytes: &[u8]) -> Line<'_> {
if is_http_request_line(text) {
return Line::Reject("HTTP is not served here: this port takes JSON lines; closing the connection".into());
}
// Checked without building values; then only the object's own keys are read, each value kept as text.
if let Err(e) = serde_json::from_str::<&serde_json::value::RawValue>(text) {
return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection"));
}
let Ok(obj) = serde_json::from_str::<Fields<'_>>(text) else {
let msg = match serde_json::from_str::<Value>(text) {
Ok(v) => v,
Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
};
let Value::Object(mut obj) = msg else {
return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
};
// `method` and `token` are decoded as strings only (anything else is no string); `id` is echoed back
// in replies, so it is decoded but bounded.
let string = |v: Option<&serde_json::value::RawValue>| v.and_then(|r| serde_json::from_str::<String>(r.get()).ok());
let Some(method) = string(obj.method) else {
let Some(Value::String(method)) = obj.remove("method") else {
return Line::Reject("not a control request (missing string `method`); closing the connection".into());
};
let id = match obj.id {
None => Value::Null,
Some(r) if r.get().len() <= MAX_ID_BYTES => match serde_json::from_str(r.get()) {
Ok(v) => v,
Err(e) => return Line::Reject(format!("bad `id` ({e}); closing the connection")),
},
Some(_) => return Line::Reject(format!("`id` is longer than {MAX_ID_BYTES} bytes; closing the connection")),
};
Line::Request { id, method, params: obj.params, token: string(obj.token) }
}
/// The request object's own keys, each value kept as JSON text. Other keys are skipped without
/// being stored: collecting them (in a map) would let an unauthenticated peer turn a line of many
/// short distinct keys into many owned strings and map nodes. A repeated key takes the last value.
#[derive(Default)]
struct Fields<'a> {
id: Option<&'a serde_json::value::RawValue>,
method: Option<&'a serde_json::value::RawValue>,
params: Option<&'a serde_json::value::RawValue>,
token: Option<&'a serde_json::value::RawValue>,
}
impl<'de> serde::Deserialize<'de> for Fields<'de> {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(serde::Deserialize)]
#[serde(field_identifier, rename_all = "lowercase")]
enum Key {
Id,
Method,
Params,
Token,
#[serde(other)]
Other,
}
struct Object;
impl<'de> serde::de::Visitor<'de> for Object {
type Value = Fields<'de>;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("a JSON object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
let mut fields = Fields::default();
while let Some(key) = map.next_key::<Key>()? {
let slot = match key {
Key::Id => &mut fields.id,
Key::Method => &mut fields.method,
Key::Params => &mut fields.params,
Key::Token => &mut fields.token,
Key::Other => {
map.next_value::<serde::de::IgnoredAny>()?;
continue;
}
};
*slot = Some(map.next_value()?);
}
Ok(fields)
}
}
d.deserialize_map(Object)
// Moved out of the parsed object, not cloned: `params` can be most of the line.
Line::Request {
id: obj.remove("id").unwrap_or(Value::Null),
method,
params: obj.remove("params").unwrap_or(json!({})),
token: obj.remove("token").and_then(|t| if let Value::String(t) = t { Some(t) } else { None }),
}
}
@@ -366,16 +305,6 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
let _ = writeln!(out, "{r}");
break;
}
// Absent `params` is `{}`; ones that cannot be decoded (an unpaired surrogate escape) are an
// error, not a request run with defaults.
let params = match params.map(|r| serde_json::from_str::<Value>(r.get())) {
None => json!({}),
Some(Ok(v)) => v,
Some(Err(e)) => {
let _ = writeln!(out, "{}", json!({"ok": false, "error": format!("bad params ({e}); closing the connection"), "id": id}));
break;
}
};
let (req, pending) = ControlRequest::new(method, params);
let mut r = match tx.try_send(req) {
Ok(()) => {
@@ -443,36 +372,6 @@ mod tests {
assert_eq!(input.len(), 100 - 11, "the rest of the line is left unread");
}
/// The parameters stay text until the token is checked, and a request decodes as before.
#[test]
fn params_are_decoded_only_as_text_by_the_parser() {
let line = br#"{"id":7,"method":"m","token":"t","params":[1,2,{"a":[3]}],"extra":null}"#;
let Line::Request { id, method, params, token } = parse_line(line) else { panic!("a request") };
assert_eq!((id, method.as_str(), token.as_deref()), (json!(7), "m", Some("t")));
assert_eq!(params.map(|p| p.get()), Some(r#"[1,2,{"a":[3]}]"#));
assert!(matches!(parse_line(b"[1,2,3]"), Line::Reject(e) if e.contains("expected a JSON object")));
assert!(matches!(parse_line(b"{\"method\":"), Line::Reject(e) if e.contains("bad JSON")));
assert!(matches!(parse_line(br#"{"id":[1],"method":5}"#), Line::Reject(e) if e.contains("missing string `method`")));
let long_id = format!(r#"{{"id":"{}","method":"m"}}"#, "x".repeat(MAX_ID_BYTES));
assert!(matches!(parse_line(long_id.as_bytes()), Line::Reject(e) if e.contains("`id` is longer")));
assert!(matches!(parse_line(br#"{"id":"\ud800","method":"m"}"#), Line::Reject(e) if e.contains("bad `id`")));
assert!(matches!(parse_line(br#"{"id":1}"#), Line::Reject(e) if e.contains("missing string `method`")));
}
/// Keys other than the request's own are skipped, not kept, however many there are; a repeated
/// key still takes the last value, and an escaped key name is the same key.
#[test]
fn unknown_keys_are_skipped_and_the_last_repeated_key_wins() {
let mut line = String::from(r#"{"method":"first","#);
for i in 0..100_000 {
line.push_str(&format!(r#""k{i}":{i},"#));
}
line.push_str(r#""method":"m","params":{"a":1},"params":[2],"token":"t"}"#);
let Line::Request { id, method, params, token } = parse_line(line.as_bytes()) else { panic!("a request") };
assert_eq!((id, method.as_str(), token.as_deref()), (Value::Null, "m", Some("t")));
assert_eq!(params.map(|p| p.get()), Some("[2]"));
}
fn held() -> Held {
Held::new(Budget::new(usize::MAX))
}
+76 -9
View File
@@ -44,6 +44,11 @@ pub use store::EntityStore;
pub use tables::*;
pub use xclip::{ClipBoundary, MAX_CLIP_VERTICES};
/// Handles at or above this are not followed: a file may name one (an object's handle, or its
/// `$HANDSEED`), and the four billion handles above the limit stay free for the drawing's own
/// growth. A file's handles keep their identity, however high they are (#913, #939).
pub const HANDLE_LIMIT: u64 = u64::MAX - 0xFFFF_FFFF;
/// File data CADCraft doesn't model, kept for saving (#528).
pub mod dynblock;
pub mod foreign;
@@ -127,6 +132,10 @@ pub struct Drawing {
pub scales: Vec<AnnoScale>,
/// Next free handle.
pub handseed: u64,
/// Handles a file's records hold in the reserved band, recorded while reading before the
/// record is placed: [`Drawing::new_handle`] skips them meanwhile. [`Drawing::bump_handseed`]
/// does not follow them (#913). Emptied once the file is read; never written to a file.
pub reserved_handles: BTreeSet<u64>,
/// Objects hidden for this session by ISOLATEOBJECTS / HIDEOBJECTS. Never written to a file:
/// a drawing opens with everything shown again.
pub hidden_objects: BTreeSet<Handle>,
@@ -200,6 +209,7 @@ impl Drawing {
parametric: Parametric::default(),
scales: imperial_scales(),
handseed: 0x100,
reserved_handles: BTreeSet::new(),
hidden_objects: BTreeSet::new(),
read_notes: Vec::new(),
refedit: None,
@@ -209,26 +219,83 @@ impl Drawing {
}
}
/// Allocate a fresh handle. It skips the handles the drawing's file gave the objects CADCraft
/// writes itself ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a
/// file CADCraft wrote numbers them above its `$HANDSEED` (#495).
/// Allocate a fresh handle: [`Drawing::next_handle`], with the seed moved past it. Past the
/// top of the range the drawing goes on growing in the reserved band (#913).
pub fn new_handle(&mut self) -> Handle {
let h = self.next_handle();
self.handseed = h.0.saturating_add(1);
self.handseed = h.0.checked_add(1).unwrap_or(HANDLE_LIMIT);
h
}
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it.
/// The handle [`Drawing::new_handle`] gives out next (AutoCAD's `HANDSEED`), without taking it:
/// the first one at or above the seed that nothing holds. It skips
/// - the handles the drawing's file gave the objects CADCraft writes itself
/// ([`foreign::Foreign::handles`]): AutoLISP names those objects by them, and a file
/// CADCraft wrote numbers them above its `$HANDSEED` (#495);
/// - handles an object or a file record being read holds in the reserved band above
/// [`HANDLE_LIMIT`]. A hostile or damaged file may name a `$HANDSEED` there, and a file
/// object may hold that same handle; the seed does not follow a file's handles in the band,
/// so taking it as-is would hand the file's object's handle to a new object and
/// `EntityStore` would replace it (#913, #1921);
/// - handle 0, which a file reads as "no handle".
///
/// Off the top of the range it goes on at the bottom of the band.
///
/// Cost: below the band the reader and [`Drawing::bump_handseed`] keep the seed above every
/// handle an object holds (AUDIT repairs a drawing where that fails), and reserved handles are
/// all in the band, so there only `foreign.handles` is looked up. The scan of every space and
/// block definition runs only for a candidate in the band. Every handle skipped is a distinct
/// one something holds, so the walk ends within one step more than the count of held handles.
pub fn next_handle(&self) -> Handle {
let held = |h: u64| {
h == 0
|| self.foreign.handles.contains_key(&Handle(h))
|| (h >= HANDLE_LIMIT && (self.reserved_handles.contains(&h) || self.handle_in_use(Handle(h))))
};
let mut h = self.handseed;
while self.foreign.handles.contains_key(&Handle(h)) && h < u64::MAX {
h = h.saturating_add(1);
// Counted only once a handle is skipped, so the usual first-try answer costs nothing.
let mut steps_left: Option<usize> = None;
while held(h) {
let left = steps_left.get_or_insert_with(|| self.held_handle_count());
let Some(rest) = left.checked_sub(1) else { break };
*left = rest;
h = h.checked_add(1).unwrap_or(HANDLE_LIMIT);
}
Handle(h)
}
/// Whether an object in any space or block definition already holds `h`.
fn handle_in_use(&self, h: Handle) -> bool {
self.model.contains(h) || self.layouts.iter().any(|l| l.entities.contains(h)) || self.blocks.values().any(|b| b.entities.contains(h))
}
/// An upper bound on how many handles [`Drawing::next_handle`] can find held, plus handle 0.
fn held_handle_count(&self) -> usize {
let spaces = self.layouts.iter().map(|l| l.entities.len()).chain(self.blocks.values().map(|b| b.entities.len()));
spaces
.fold(self.model.len(), usize::saturating_add)
.saturating_add(self.foreign.handles.len())
.saturating_add(self.reserved_handles.len())
.saturating_add(1)
}
/// Record a handle a file's record holds in the reserved band, before the record is placed in
/// the drawing, so [`Drawing::new_handle`] does not hand it to an object read earlier (#1276).
///
/// Only handles at or above [`HANDLE_LIMIT`] are recorded: below it [`Drawing::bump_handseed`]
/// already moves the seed past them. The reservation stays separate from the seed because the
/// writer's growth lives above the limit and a file's handles there are not followed (#913).
pub fn reserve_handle(&mut self, h: Handle) {
if h.0 >= HANDLE_LIMIT {
self.reserved_handles.insert(h.0);
}
}
/// Make sure future handles don't collide with `h` (after loading a file).
///
/// A handle at or above [`HANDLE_LIMIT`] is the file's own and stays as it is: it is not
/// followed, so a new object is never given the top handle and the file's object is never
/// replaced (#913). The handles above the limit are the drawing's room to grow.
pub fn bump_handseed(&mut self, h: Handle) {
if h.0 >= self.handseed {
self.handseed = h.0.saturating_add(1);
if h.0 >= self.handseed && h.0 < HANDLE_LIMIT {
self.handseed = h.0 + 1;
}
}
+28
View File
@@ -726,6 +726,34 @@ fn new_handles_skip_the_files_object_handles() {
assert_eq!(d.new_handle(), Handle(next + 3));
}
/// In the reserved band a new handle skips the file's kept object handles (#2514) and the handles
/// objects hold in model space, a layout and a block definition, or that a file record reserved
/// (#913); off the top of the range it goes on at the bottom of the band. HANDSEED reports the
/// handle `new_handle` takes.
#[test]
fn new_handles_in_the_reserved_band_skip_every_held_handle_and_wrap() {
let mut d = Drawing::new_metric();
let top = u64::MAX;
d.model.push(Entity::new(Handle(top - 4), line((0.0, 0.0), (1.0, 0.0))));
let mut sheet = Layout::new("Sheet", 1);
sheet.entities.push(Entity::new(Handle(top - 3), line((0.0, 0.0), (1.0, 0.0))));
d.layouts.push(sheet);
let mut b = Block::new("B");
b.entities.push(Entity::new(Handle(top - 2), line((0.0, 0.0), (1.0, 0.0))));
d.blocks.insert("B".into(), std::sync::Arc::new(b));
std::sync::Arc::make_mut(&mut d.foreign).handles.insert(Handle(top - 1), ("LAYER".into(), "0".into()));
d.reserve_handle(Handle(top));
d.model.push(Entity::new(Handle(HANDLE_LIMIT), line((0.0, 0.0), (1.0, 0.0))));
d.handseed = top - 5;
assert_eq!(d.new_handle(), Handle(top - 5));
assert_eq!(d.next_handle(), Handle(HANDLE_LIMIT + 1), "a held handle was offered");
assert_eq!(d.new_handle(), Handle(HANDLE_LIMIT + 1));
assert_eq!(d.handseed, HANDLE_LIMIT + 2);
// Handle 0 means "no handle" in a file; a seed there moves on.
d.handseed = 0;
assert_eq!(d.new_handle(), Handle(1));
}
/// Several spellings of one DIM field apply once, the last in the map's order, and none is rejected.
#[test]
fn dim_style_spellings_of_one_field_apply_once() {
+7 -1
View File
@@ -319,8 +319,14 @@ fn all_handles(d: &Drawing) -> HashSet<Handle> {
}
/// The next handle is above every handle in use, so new objects never take an existing one.
///
/// A handle at or above [`cadcraft_doc::HANDLE_LIMIT`] is the file's own and is deliberately not
/// followed: the seed never moves past it, and new objects take free handles in the band above
/// the limit. Reporting it would repeat the same repair on every audit, so it is not an issue.
/// Such a handle is left out of the maximum too, or the largest handle would hide every ordinary
/// one behind it and the seed would never be repaired past them.
fn handseed(d: &mut Drawing, out: &mut Vec<Issue>) {
let Some(max) = each_entity(d).map(|e| e.handle).max() else { return };
let Some(max) = each_entity(d).map(|e| e.handle).filter(|h| h.0 < cadcraft_doc::HANDLE_LIMIT).max() else { return };
if max.0 >= d.handseed {
out.push(issue(
"handseed",
-8
View File
@@ -134,7 +134,6 @@ fn run_recover(s: &mut Session, p: &Value) -> Result<Value> {
Ok(r)
}
/// Write the report to the `.adt` file beside the saved drawing, held to the automation roots.
#[cfg(not(target_arch = "wasm32"))]
fn write_audit_log(s: &Session, report: &crate::audit::Report) {
let (path_str, title) = match s.state() {
@@ -144,10 +143,6 @@ fn write_audit_log(s: &Session, report: &crate::audit::Report) {
// An unsaved drawing has no folder of its own to hold the log.
let Some(path) = &path_str else { return };
let adt_path = std::path::PathBuf::from(path).with_extension("adt");
if let Err(e) = crate::file_access::check_write(&adt_path) {
log::warn!("AUDITCTL: not writing audit log {}: {e}", adt_path.display());
return;
}
let content = report.format_adt(&title, path_str.as_deref());
// Write through an exclusively-created temporary and rename over the companion path, so a
// planted `.adt` symlink beside the drawing cannot redirect the report onto another file
@@ -161,13 +156,10 @@ fn write_audit_log(s: &Session, report: &crate::audit::Report) {
fn write_audit_log(_: &Session, _: &crate::audit::Report) {}
#[cfg(not(target_arch = "wasm32"))]
/// The bytes of the file at `path`, once the automation roots allow reading it.
fn read_path(cmd: &str, path: &str) -> Result<Vec<u8>> {
crate::file_access::check_read(path).map_err(|e| bad(cmd, e))?;
crate::capped_read::read_capped(std::path::Path::new(path), file::MAX_DRAWING_BYTES).map_err(|e| bad(cmd, format!("{path}: {e}")))
}
/// The bytes of the drawing at `path`, held to the automation roots.
#[cfg(target_arch = "wasm32")]
fn read_path(cmd: &str, _path: &str) -> Result<Vec<u8>> {
Err(bad(cmd, "paths are not available on the web; pass `data`"))
-2
View File
@@ -260,11 +260,9 @@ fn csv(columns: &[String], rows: &[Vec<Cell>], sep: char) -> String {
out
}
/// Write the extracted table to `path`, held to the automation roots.
fn write_file(path: &str, text: &str) -> Result<()> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(path).map_err(EngineError::Other)?;
std::fs::write(path, text).map_err(|e| EngineError::Other(format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
@@ -88,11 +88,9 @@ pub(super) fn read_drawing(path: &str) -> Result<Drawing> {
Err(last.unwrap_or_else(|| bad("insert", format!("{path}: file not found"))))
}
/// The bytes of the drawing to insert, held to the automation roots.
fn read_file(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad("insert", e))?;
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
.map_err(|e| bad("insert", format!("{_path}: {e}")))
}
-25
View File
@@ -70,8 +70,6 @@ fn stamp(path: &str) -> Option<(u64, Option<SystemTime>)> {
/// A library drawing, read once and kept while the file is as it was: placing a block must not
/// parse the whole file again.
fn cached_drawing(path: &str) -> Result<Arc<Drawing>> {
// Before the cache too: a drawing read earlier must not be handed out past the roots.
crate::file_access::check_read(path).map_err(|e| bad("blocklibrary", e))?;
// The reader sniffs the bytes, so a DXF named `part.bin` would load: the contract is DWG/DXF by name.
if !is_drawing(Path::new(path)) {
return Err(bad("blocklibrary", format!("{path}: expected a DWG or DXF file")));
@@ -188,9 +186,6 @@ pub fn read_library_file(path: &str) -> Result<Arc<Drawing>> {
/// What BLOCKLIBRARY answers for `path`. It needs no session, so the palette reads big drawings
/// and slow folders on a worker thread.
pub fn list_library(path: &str) -> Result<Value> {
// Before anything looks at the path: a folder's listing, or whether it is one, says what is
// outside the automation roots.
crate::file_access::check_read(path).map_err(|e| bad("blocklibrary", e))?;
if is_folder(path) {
let (files, truncated) = folder_files(Path::new(path))?;
let list: Vec<Value> = files.iter().map(|(name, file)| json!({ "name": name, "file": file })).collect();
@@ -361,26 +356,6 @@ fn run_libraries(_s: &mut Session, p: &Value) -> Result<Value> {
mod tests {
use super::*;
/// Under the automation roots a library folder or file outside them is refused before it is
/// listed or read.
#[test]
fn the_automation_roots_hold_library_paths() {
let base = std::env::temp_dir().join(format!("cadcraft-library-roots-{}", std::process::id()));
let (inside, outside) = (base.join("in"), base.join("outside"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
std::fs::write(outside.join("parts.dxf"), b"0\nEOF\n").unwrap();
let roots = crate::file_access::AutomationRoots::new(Some(&inside), None).unwrap();
crate::file_access::confine(roots.as_ref(), || {
let folder = list_library(&outside.to_string_lossy()).map(|v| v.to_string());
assert!(folder.as_ref().is_err_and(|e| e.to_string().contains("automation")), "{folder:?}");
let file = list_library(&outside.join("parts.dxf").to_string_lossy()).map(|v| v.to_string());
assert!(file.as_ref().is_err_and(|e| e.to_string().contains("automation")), "{file:?}");
assert!(list_library(&inside.to_string_lossy()).is_ok());
});
let _ = std::fs::remove_dir_all(&base);
}
/// A list that could not be written stays the list of this session, whatever the file says.
#[test]
fn a_failed_write_keeps_the_list_in_memory() {
+1 -5
View File
@@ -105,8 +105,6 @@ fn write(s: &Session, cmd: &str, path: &str, what: Source) -> Result<(usize, usi
let bytes = (hooks.write)(&d, path).map_err(|e| bad(cmd, e))?;
// Through a temporary file, as SAVE writes, so a failed write keeps the file it replaces.
#[cfg(not(target_arch = "wasm32"))]
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
#[cfg(not(target_arch = "wasm32"))]
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
let lost = if drops_unknown(path) { not_saved(&d) } else { BTreeMap::new() };
Ok((d.model.len(), bytes.len(), lost))
@@ -172,9 +170,7 @@ fn output_path(typed: &str) -> String {
fn exists(path: &str) -> bool {
#[cfg(not(target_arch = "wasm32"))]
{
// Outside the automation roots the answer would say whether a file is there; the write
// that follows is refused anyway.
crate::file_access::check_write(path).is_ok() && std::path::Path::new(path).exists()
std::path::Path::new(path).exists()
}
#[cfg(target_arch = "wasm32")]
{
-4
View File
@@ -408,7 +408,6 @@ fn run_xbind(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "bound": bound }))
}
/// Open the file a selected reference points at, as its own drawing.
fn run_xopen(s: &mut Session, p: &Value) -> Result<Value> {
let d = s.doc()?;
let name = match str_param(p, "name") {
@@ -430,9 +429,6 @@ fn run_xopen(s: &mut Session, p: &Value) -> Result<Value> {
let file = load::find(&path, host.as_deref().map(std::path::Path::new), false).map_err(|m| match m {
load::Missing::NotFound => bad("xopen", format!("{path}: file not found")),
load::Missing::Refused(r) => bad("xopen", format!("{path}: not opened, {r}")),
load::Missing::OutsideRoots => {
bad("xopen", format!("{path}: not opened, automation path rejected: outside the read root (or the write root)"))
}
})?;
s.execute("open", &json!({ "path": file.to_string_lossy() }))
}
+17 -98
View File
@@ -145,12 +145,9 @@ pub(crate) enum Missing {
NotFound,
/// The saved path isn't followed, and there is no file of its name beside the host.
Refused(Refused),
/// The automation roots don't reach the file ([`crate::file_access`]).
OutsideRoots,
}
impl Missing {
/// The status and message a reference gets when its file can't be loaded.
fn outcome(self, path: &str) -> (XrefStatus, String) {
match self {
Self::NotFound => {
@@ -158,9 +155,6 @@ impl Missing {
(XrefStatus::NotFound, format!("{path}: {why}"))
}
Self::Refused(r) => (XrefStatus::Unresolved, format!("{path}: not opened, {r}")),
Self::OutsideRoots => {
(XrefStatus::Unresolved, format!("{path}: not opened, automation path rejected: outside the read root (or the write root)"))
}
}
}
}
@@ -214,36 +208,14 @@ pub(crate) fn find(path: &str, host: Option<&Path>, chosen: bool) -> Result<Path
return Err(Missing::NotFound);
}
let (files, refused) = candidates(path, host, chosen);
// Outside the automation roots a place isn't even looked at, so the answer can't tell whether a
// file is there. A match found by ignoring case is checked again: it can be a link leading out.
let allowed = |p: &PathBuf| crate::file_access::check_read(p).is_ok();
let looked_for = files.len();
let files: Vec<PathBuf> = files.into_iter().filter(allowed).collect();
let outside = files.len() < looked_for;
// A match found by ignoring case that the roots refuse counts as outside them too.
#[cfg(not(target_arch = "wasm32"))]
let mut refused_match = false;
#[cfg(not(target_arch = "wasm32"))]
let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| {
files.iter().find_map(|p| {
let c = match case_insensitive(p) {
Ok(Some(c)) => c,
Ok(None) => return None,
Err(()) => {
refused_match = true;
return None;
}
};
let ok = allowed(&c);
refused_match |= !ok;
ok.then_some(c)
})
});
#[cfg(not(target_arch = "wasm32"))]
let outside = outside || refused_match;
let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| files.iter().find_map(|p| case_insensitive(p)));
#[cfg(target_arch = "wasm32")]
let found: Option<PathBuf> = None;
found.ok_or(if outside { Missing::OutsideRoots } else { refused.map_or(Missing::NotFound, Missing::Refused) })
let found: Option<PathBuf> = {
let _ = files;
None
};
found.ok_or(refused.map_or(Missing::NotFound, Missing::Refused))
}
/// Upper bound on directory entries scanned per path component by [`case_insensitive`].
@@ -253,16 +225,10 @@ const MAX_CASE_SCAN: usize = 10_000;
/// The existing file `p` names when its letters' case is ignored, on file systems that don't
/// ignore it themselves. Drawings made on Windows often store a reference as `PLAN.DWG` for
/// `Plan.dwg`; Windows finds it, and so should Linux. Each missing component is matched against
/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing. `Err` when
/// the automation roots refuse a place it would have to look in.
/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing.
#[cfg(not(target_arch = "wasm32"))]
fn case_insensitive(p: &Path) -> Result<Option<PathBuf>, ()> {
fn case_insensitive(p: &Path) -> Option<PathBuf> {
use std::path::Component;
// Under the automation roots a place is probed only when the roots allow it, or when it lies on
// the way to `p` as it was spelled (which was checked): a name corrected to another case could be
// a link leading out, and looking inside it would look outside the roots.
let mut corrected = false;
let probe = |q: &Path, corrected: bool| (!corrected && p.starts_with(q)) || crate::file_access::check_read(q).is_ok();
let mut out = PathBuf::new();
for c in p.components() {
let Component::Normal(name) = c else {
@@ -270,27 +236,23 @@ fn case_insensitive(p: &Path) -> Result<Option<PathBuf>, ()> {
continue;
};
let exact = out.join(name);
if !probe(&exact, corrected) {
return Err(());
}
if exact.exists() {
out = exact;
continue;
}
let Some(want) = name.to_str().map(str::to_lowercase) else { return Ok(None) };
let Ok(entries) = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out }) else { return Ok(None) };
let mut hits = entries.take(MAX_CASE_SCAN).flatten().filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
let Some(hit) = hits.next() else { return Ok(None) };
let want = name.to_str()?.to_lowercase();
let mut hits = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out })
.ok()?
.take(MAX_CASE_SCAN)
.flatten()
.filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
let hit = hits.next()?;
if hits.next().is_some() {
return Ok(None);
return None;
}
out.push(hit.file_name());
corrected = true;
if !probe(&out, corrected) {
return Err(());
}
}
Ok(out.is_file().then_some(out))
out.is_file().then_some(out)
}
/// Read a drawing file through the host's io hooks, counting its bytes against the load's total.
@@ -299,7 +261,6 @@ fn read(file: &Path, cx: &mut Ctx) -> Result<Drawing, String> {
#[cfg(not(target_arch = "wasm32"))]
{
use std::io::Read;
crate::file_access::check_read(file)?;
let left = MAX_XREF_TOTAL_BYTES.saturating_sub(cx.bytes);
let limit = MAX_XREF_BYTES.min(left);
let mut f = std::fs::File::open(file).map_err(|e| e.to_string())?;
@@ -642,48 +603,6 @@ mod tests {
assert_eq!(find("", Some(&host), false), Err(Missing::NotFound));
}
/// A name corrected to another case is checked against the roots before it is looked inside, and a
/// match they refuse leaves the other candidates to be tried.
#[cfg(unix)]
#[test]
fn a_name_corrected_to_a_link_out_of_the_roots_is_not_looked_inside() {
use crate::file_access::{AutomationRoots, confine};
let base = std::env::temp_dir().join(format!("cc-xref-case-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
for d in ["in/sub", "outside"] {
std::fs::create_dir_all(base.join(d)).unwrap();
}
std::fs::write(base.join("outside/target.dxf"), "x").unwrap();
std::fs::write(base.join("in/Mixed.dxf"), "x").unwrap();
std::os::unix::fs::symlink(base.join("outside"), base.join("in/Alias")).unwrap();
std::os::unix::fs::symlink(base.join("outside/target.dxf"), base.join("in/sub/Mixed.dxf")).unwrap();
if base.join("in/alias").exists() {
// A case-insensitive file system never needs a name corrected: nothing to test.
eprintln!("skipped: this file system ignores case");
std::fs::remove_dir_all(&base).unwrap();
return;
}
let roots = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
confine(Some(&roots), || {
// `alias` isn't there but `Alias` is, a link out: the probe stops before looking in it.
assert_eq!(case_insensitive(&base.join("in/alias/target.dxf")), Err(()));
// A match that leaves the roots doesn't end the search: the next candidate is tried.
let host = base.join("in/host.dxf");
let found = find("sub/mixed.dxf", Some(&host), true).unwrap();
assert_eq!(found, base.join("in/Mixed.dxf"));
// With no other candidate it is still a refusal by the roots, not a missing file.
std::fs::create_dir_all(base.join("in/lone")).unwrap();
std::os::unix::fs::symlink(base.join("outside/target.dxf"), base.join("in/lone/Only.dxf")).unwrap();
assert_eq!(find("lone/only.dxf", Some(&host), true), Err(Missing::OutsideRoots));
});
assert_eq!(
case_insensitive(&base.join("in/alias/target.dxf")),
Ok(Some(base.join("in/Alias/target.dxf"))),
"without roots the link is followed"
);
std::fs::remove_dir_all(&base).unwrap();
}
#[test]
fn prefixes_ignore_case() {
assert!(has_prefix("SITE|Walls", "site|"));
-3
View File
@@ -82,7 +82,6 @@ fn write_file(cmd: &str, path: &str, bytes: &[u8]) -> Result<()> {
{
// Exclusively create a fresh temporary file and rename it into place so a planted
// `<path>.cadcraft-tmp` symlink cannot redirect the export write (CWE-59).
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
@@ -202,11 +201,9 @@ fn import_drawing(s: &mut Session, src: &Drawing, at: Vec2, scale: f64, file: &s
}))
}
/// The bytes of the file to import, held to the automation roots.
fn read_file(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad("import", e))?;
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
.map_err(|e| bad("import", format!("{_path}: {e}")))
}
+2 -33
View File
@@ -240,7 +240,6 @@ fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
let path = _path;
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(path).map_err(|e| bad("script", e))?;
let bytes =
crate::capped_read::read_capped(std::path::Path::new(path), MAX_SCRIPT_BYTES).map_err(|e| bad("script", format!("{path}: {e}")))?;
String::from_utf8_lossy(&bytes).into_owned()
@@ -321,7 +320,6 @@ pub fn read_file(path: &std::path::Path) -> std::result::Result<ReadFile, String
let Some(text_path) = path.to_str() else {
return Err(bad("open", format!("{shown}: the file name is not valid Unicode, so CADCraft can't save back to it")));
};
crate::file_access::check_read(text_path).map_err(|e| bad("open", e))?;
let bytes = crate::capped_read::read_capped(path, MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{shown}: {e}")))?;
read_bytes(&bytes, text_path, Some(text_path.to_string()))
});
@@ -346,7 +344,6 @@ pub fn finish_open(s: &mut Session, f: ReadFile) -> Result<Value> {
Ok(opened(s, i, true))
}
/// Parse a drawing's bytes, and search its folder for fonts where the automation roots allow.
fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile> {
let hooks = io().ok_or_else(|| bad("open", "file formats are not available in this build"))?;
let drawing = (hooks.read)(bytes, name).map_err(|e| bad("open", e))?;
@@ -357,17 +354,7 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
if let Some(dir) = path.as_deref().and_then(|p| std::path::Path::new(p).parent()) {
// A bare file name is in the current folder.
let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
let dir = std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf());
match crate::file_access::current() {
None => cadcraft_fonts::shx::add_drawing_dir(&dir),
// The folder holds no record of the roots, and a font's name there can be a link leading
// out of them: the search asks the roots about each file before it opens one.
Some(roots) => {
let owner = format!("{:?}|{:?}", roots.read_root(), roots.write_root());
let guard = std::sync::Arc::new(move |font: &std::path::Path| roots.check(font, crate::file_access::Access::Read).is_ok());
cadcraft_fonts::shx::add_drawing_dir_guarded(&dir, &owner, guard);
}
}
cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
}
Ok(ReadFile { drawing, binary_dxf: craft_dxf::is_binary(bytes), name: name.to_string(), path })
}
@@ -410,7 +397,6 @@ fn run_open(s: &mut Session, p: &Value) -> Result<Value> {
let path = _path;
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(path).map_err(|e| bad("open", e))?;
let bytes =
crate::capped_read::read_capped(std::path::Path::new(path), MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{path}: {e}")))?;
let i = open_bytes(s, &bytes, path, Some(path.to_string()))?;
@@ -496,7 +482,6 @@ fn save_as(s: &mut Session, cmd: &str, path: &str, opts: &SaveAs) -> Result<usiz
fn store(path: &str, bytes: &[u8]) -> Result<()> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(path).map_err(|e| bad("save", e))?;
// A file in a folder still to be made has nothing to back up.
if is_drawing_file(path) && crate::autosave::isavebak() && crate::atomic_write::missing_folder(std::path::Path::new(path)).is_none() {
backup(std::path::Path::new(path))
@@ -706,9 +691,7 @@ fn backup(path: &std::path::Path) -> std::io::Result<()> {
};
let (head, tail, len) = ends(&mut src)?;
let bak = backup_path(path);
// Whether the .bak name is taken is asked without following a link there: a link leading out of
// the roots (or to another computer) isn't looked at.
if !backup_replaced(&head, &tail, len, std::fs::symlink_metadata(&bak).is_ok()) {
if !backup_replaced(&head, &tail, len, bak.exists()) {
log::warn!("save: {} doesn't look like a whole drawing; its backup is left as it was", path.display());
return Ok(());
}
@@ -1072,20 +1055,6 @@ mod tests {
use crate::Session;
use crate::temp_dir::TempDir;
/// Whether the `.bak` name is taken is asked without following a link there: a dangling link
/// counts as taken, so a file that doesn't look like a drawing leaves it alone.
#[cfg(unix)]
#[test]
fn a_link_at_the_bak_name_counts_as_a_backup_without_being_followed() {
let dir = TempDir::new("cc-bak-link");
let path = dir.join("plain.dxf");
std::fs::write(&path, "just some text, not a drawing").unwrap();
let bak = super::backup_path(&path);
std::os::unix::fs::symlink(dir.join("nowhere"), &bak).unwrap();
super::backup(&path).unwrap();
assert!(std::fs::symlink_metadata(&bak).unwrap().file_type().is_symlink(), "the link is left as it was");
}
/// A backup is never more open than the drawing or the old `.bak`, and loses the group bits when
/// it would keep the old `.bak`'s group while the drawing is in another.
#[cfg(unix)]
-2
View File
@@ -107,11 +107,9 @@ fn other_drawing(s: &Session, p: &Value) -> Result<(Arc<Drawing>, String)> {
Ok((Arc::new(d), name))
}
/// The bytes of the drawing to compare with, held to the automation roots.
fn read_path(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad("compare", e))?;
crate::capped_read::read_capped(std::path::Path::new(_path), super::MAX_DRAWING_BYTES).map_err(|e| bad("compare", format!("{_path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+6 -6
View File
@@ -128,8 +128,8 @@ pub fn alias_name(a: &str) -> std::result::Result<String, String> {
}
/// The aliases of a `.pgp` file's text, and its problems.
fn parse(text: &str) -> (BTreeMap<String, String>, Vec<String>) {
let mut out = BTreeMap::new();
fn parse(text: &str) -> (Vec<(String, String)>, Vec<String>) {
let mut out: Vec<(String, String)> = Vec::new();
let mut warnings = Vec::new();
let mut warn = |no: usize, msg: String| {
if warnings.len() < MAX_WARNINGS {
@@ -165,13 +165,13 @@ fn parse(text: &str) -> (BTreeMap<String, String>, Vec<String>) {
warn(no, format!("{}: unknown command {}; skipped", alias.trim(), target.trim()));
continue;
};
// Once full, stop at the next valid definition, even if it repeats an alias.
if out.len() >= MAX_ALIASES {
warn(no, format!("more than {MAX_ALIASES} aliases; the rest are skipped"));
break;
}
// A later definition wins without scanning all the aliases accumulated so far.
out.insert(name, id);
// A later line for the same alias wins, as it would when typed into the file twice.
out.retain(|(a, _)| *a != name);
out.push((name, id));
}
(out, warnings)
}
@@ -185,7 +185,7 @@ fn listing(warnings: &[String], added: usize) -> Value {
fn load(text: &str, path: Option<String>) -> (usize, Vec<String>) {
let (aliases, warnings) = parse(text);
let mut st = store();
st.map = aliases;
st.map = aliases.into_iter().collect();
if path.is_some() {
st.file = path;
}
-3
View File
@@ -73,13 +73,10 @@ fn read_template(path: &str) -> Result<Drawing> {
}
#[cfg(not(target_arch = "wasm32"))]
/// The bytes of the template at `path`, once the automation roots allow reading it.
fn read_bytes(path: &str) -> Result<Vec<u8>> {
crate::file_access::check_read(path).map_err(|e| bad("new", e))?;
crate::capped_read::read_capped(std::path::Path::new(path), super::MAX_DRAWING_BYTES).map_err(|e| bad("new", format!("template {path}: {e}")))
}
/// The bytes of the template at `path`, held to the automation roots.
#[cfg(target_arch = "wasm32")]
fn read_bytes(path: &str) -> Result<Vec<u8>> {
Err(bad("new", format!("template {path}: paths are not available on the web")))
-3
View File
@@ -115,10 +115,8 @@ pub fn support_text(cmd: &str, p: &serde_json::Value, path_key: &str, text_key:
}
#[cfg(not(target_arch = "wasm32"))]
/// The text of the support file at `path`, once the automation roots allow reading it, up to the size limit.
fn read_support_file(cmd: &str, path: &str) -> crate::Result<String> {
use std::io::Read;
crate::file_access::check_read(path).map_err(|e| super::bad(cmd, e))?;
let f = std::fs::File::open(path).map_err(|e| super::bad(cmd, format!("{path}: {e}")))?;
let mut bytes = Vec::new();
f.take(MAX_SUPPORT_FILE_BYTES + 1).read_to_end(&mut bytes).map_err(|e| super::bad(cmd, format!("{path}: {e}")))?;
@@ -128,7 +126,6 @@ fn read_support_file(cmd: &str, path: &str) -> crate::Result<String> {
Ok(String::from_utf8_lossy(&bytes).into_owned())
}
/// The text of a support file (a linetype or hatch pattern file, say), size-limited and held to the automation roots.
#[cfg(target_arch = "wasm32")]
fn read_support_file(cmd: &str, _path: &str) -> crate::Result<String> {
Err(super::bad(cmd, "paths are not available on the web; pass the file's contents"))
+38 -15
View File
@@ -18,8 +18,13 @@ use crate::{Result, Session};
/// Most image files loaded per drawing.
const MAX_IMAGE_FILES: usize = 1000;
/// Largest image file read (bytes).
#[cfg(not(target_arch = "wasm32"))]
const MAX_IMAGE_BYTES: u64 = 256 << 20;
/// Longest base64 text taken for `data`: what a file of [`MAX_IMAGE_BYTES`] encodes to.
const MAX_IMAGE_BASE64: u64 = MAX_IMAGE_BYTES.div_ceil(3) * 4;
/// Longest `data` text with the line breaks and spaces base64 may carry (MIME breaks every 76
/// characters, under 3% more): the characters past [`MAX_IMAGE_BASE64`] are counted only up to
/// here, which also bounds what decoding sets aside.
const MAX_IMAGE_TEXT: u64 = MAX_IMAGE_BASE64 + MAX_IMAGE_BASE64 / 16;
/// Most decoded pixel bytes kept per drawing; images past it stay unloaded.
const MAX_LOADED_BYTES: u64 = 2 << 30;
/// Most image files decoded at the same time when a drawing opens.
@@ -70,12 +75,22 @@ fn paths(d: &Drawing) -> Vec<String> {
paths
}
/// Whether `path` is a full path here, or on Windows where a drawing may have been written (a
/// drive, `C:\maps\a.png`, or a share, `\\server\maps`), which other systems read as relative.
#[cfg(not(target_arch = "wasm32"))]
fn full_path(path: &str) -> bool {
let b = path.trim().as_bytes();
std::path::Path::new(path.trim()).is_absolute() || b.starts_with(b"\\\\") || matches!(b, [d, b':', b'\\' | b'/', ..] if d.is_ascii_alphabetic())
}
/// The contents of the image file saved as `path` in a drawing at `host`.
fn read_file(path: &str, host: Option<&str>) -> std::result::Result<Vec<u8>, String> {
#[cfg(not(target_arch = "wasm32"))]
{
let file = super::blocks::xref::find_file(path, host).ok_or("file not found")?;
crate::file_access::check_read(&file)?;
let file = super::blocks::xref::find_file(path, host).ok_or_else(|| {
// An unsaved drawing has no folder for a relative path to be relative to.
if host.is_none() && !full_path(path) { "file not found (save the drawing first, or give a full path)" } else { "file not found" }
})?;
let len = std::fs::metadata(&file).map_err(|e| e.to_string())?.len();
if len > MAX_IMAGE_BYTES {
return Err(format!("the file is larger than {} MB", MAX_IMAGE_BYTES >> 20));
@@ -181,18 +196,14 @@ fn decode_files(paths: &[&str], host: Option<&str>) -> Vec<std::result::Result<R
if loaders > 1 {
// Each loader takes the next file nobody has started.
let next = AtomicUsize::new(0);
// The automation roots are per thread, so they go along with each loader.
let roots = crate::file_access::current();
let work = || {
crate::file_access::confine(roots.as_ref(), || {
let mut done = Vec::new();
loop {
let index = next.fetch_add(1, Ordering::Relaxed);
let Some(path) = paths.get(index) else { break };
done.push((index, load(path)));
}
done
})
let mut done = Vec::new();
loop {
let index = next.fetch_add(1, Ordering::Relaxed);
let Some(path) = paths.get(index) else { break };
done.push((index, load(path)));
}
done
};
let finished: Vec<_> = std::thread::scope(|scope| {
let started: Vec<_> = (0..loaders).filter_map(|_| std::thread::Builder::new().spawn_scoped(scope, work).ok()).collect();
@@ -309,7 +320,19 @@ fn pixels(s: &Session, p: &Value, path: &str) -> Result<Arc<Raster>> {
let bytes = match p.get("data") {
Some(data) => {
let text = data.as_str().ok_or_else(|| bad(ID, "`data` must be base64 text"))?;
base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?
// Refused before decoding, which would hold all of it in memory. Line breaks and
// spaces, which decoding skips, don't count.
let len = u64::try_from(text.len()).unwrap_or(u64::MAX);
let digits = || u64::try_from(text.bytes().filter(|b| !matches!(b, b'\n' | b'\r' | b' ')).count()).unwrap_or(u64::MAX);
if len > MAX_IMAGE_TEXT || (len > MAX_IMAGE_BASE64 && digits() > MAX_IMAGE_BASE64) {
return Err(bad(ID, format!("`data` is larger than {} MB", MAX_IMAGE_BYTES >> 20)));
}
let bytes = base64_decode(text).ok_or_else(|| bad(ID, "`data` is not valid base64"))?;
// The longest text allowed can still hold a byte or two more than the limit.
if u64::try_from(bytes.len()).unwrap_or(u64::MAX) > MAX_IMAGE_BYTES {
return Err(bad(ID, format!("`data` is larger than {} MB", MAX_IMAGE_BYTES >> 20)));
}
bytes
}
None => {
if let Some(loaded) = s.doc()?.rasters.get(path) {
-1
View File
@@ -864,7 +864,6 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
let path = _path;
// Exclusively create a fresh temporary file and rename it into place so a planted
// `<path>.cadcraft-tmp` symlink cannot redirect the plot write (CWE-59).
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
let folder = super::file::new_folder(path);
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
let mut r = json!({ "path": path, "bytes": bytes.len(), "layout": layout, "pages": pages, "format": format });
@@ -187,7 +187,6 @@ fn edit_style(cmd: &str, st: &mut PlotStyle, v: &Value) -> Result<()> {
Ok(())
}
/// List, read, change, load and export plot style tables; any file is held to the automation roots.
fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "stylesmanager";
let action = str_param(p, "action").unwrap_or("list").to_ascii_lowercase();
@@ -304,7 +303,6 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
(None, Some(_path)) => {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad(cmd, e))?;
let bytes = crate::capped_read::read_capped(std::path::Path::new(_path), cadcraft_doc::MAX_TABLE_FILE)
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
String::from_utf8(bytes).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
@@ -333,7 +331,6 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
Some(_path) => {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(_path).map_err(|e| bad(cmd, e))?;
crate::atomic_write::write_atomic(std::path::Path::new(_path), text.as_bytes())
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
Ok(json!({ "name": name, "path": _path, "bytes": text.len() }))
-1
View File
@@ -145,7 +145,6 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
{
// Exclusively create a fresh temporary file and rename it into place so a planted
// `<path>.cadcraft-tmp` symlink cannot redirect the write (CWE-59).
crate::file_access::check_write(path).map_err(|e| bad("layout.saveas", e))?;
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad("layout.saveas", format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+3 -20
View File
@@ -79,9 +79,7 @@ impl PlotterStore {
}
PlotterStore {
list: || {
let d = dir()?;
crate::file_access::check_read(&d)?;
let rd = match std::fs::read_dir(d) {
let rd = match std::fs::read_dir(dir()?) {
Ok(rd) => rd,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
Err(e) => return Err(e.to_string()),
@@ -94,7 +92,6 @@ impl PlotterStore {
},
read: |n| {
let p = file(n)?;
crate::file_access::check_read(&p)?;
let len = std::fs::metadata(&p).map_err(|e| format!("{n}: {e}"))?.len();
if len > cadcraft_doc::MAX_PLOTTER_FILE as u64 {
return Err(format!("{n}: the plotter configuration file is too large"));
@@ -103,16 +100,10 @@ impl PlotterStore {
},
write: |n, t| {
let p = file(n)?;
// Checked before the folder it lives in is created. The temporary file sits beside it.
crate::file_access::check_write(&p)?;
std::fs::create_dir_all(dir()?).map_err(|e| e.to_string())?;
crate::atomic_write::write_atomic(&p, t.as_bytes()).map_err(|e| format!("{n}: {e}"))
},
delete: |n| {
let p = file(n)?;
crate::file_access::check_write(&p)?;
std::fs::remove_file(p).map_err(|e| format!("{n}: {e}"))
},
delete: |n| std::fs::remove_file(file(n)?).map_err(|e| format!("{n}: {e}")),
}
}
}
@@ -556,18 +547,11 @@ fn edit_device(cmd: &str, c: &mut PlotterConfig, p: &Value) -> Result<()> {
Ok(())
}
/// List, read, change, load, export and delete plotter configurations; any file is held to the automation roots.
fn run_plottermanager(_s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "plottermanager";
let action = str_param(p, "action").unwrap_or("list").trim().to_ascii_lowercase();
match action.as_str() {
"list" => {
// Under the roots a refused settings folder is an error, not a short list.
if crate::file_access::current().is_some() {
(store().list)().map_err(|e| bad(cmd, e))?;
}
Ok(json!({ "devices": devices().iter().map(summary).collect::<Vec<_>>() }))
}
"list" => Ok(json!({ "devices": devices().iter().map(summary).collect::<Vec<_>>() })),
"get" => {
let n = device_name(cmd, p)?;
let c = find_device(&n).ok_or_else(|| unknown_device(cmd, &n))?;
@@ -652,7 +636,6 @@ fn run_plottermanager(_s: &mut Session, p: &Value) -> Result<Value> {
Some(_path) => {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(_path).map_err(|e| bad(cmd, e))?;
std::fs::write(_path, &text).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
Ok(json!({ "name": name, "path": _path }))
}
-1
View File
@@ -238,7 +238,6 @@ fn read_link(id: &str, file: &std::path::Path) -> Result<String> {
let path = file.display();
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(file).map_err(|e| bad(id, e))?;
// The limit is enforced on the bytes read, not on reported metadata, so a device or FIFO
// that misreports its length can't be buffered to EOF.
let bytes = crate::capped_read::read_capped(file, MAX_LINK_BYTES).map_err(|e| bad(id, format!("{path}: {e}")))?;
-1
View File
@@ -514,7 +514,6 @@ pub(crate) fn table_csv(t: &Table, sep: char) -> String {
fn write_text(path: &str, text: &str) -> Result<()> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(path).map_err(|e| bad("tableexport", e))?;
std::fs::write(path, text).map_err(|e| bad("tableexport", format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
-781
View File
@@ -1,781 +0,0 @@
//! The folders automation may read and write (#1472).
//!
//! `cadcraft-cli mcp --automation-read-root <dir> --automation-write-root <dir>` confines the files
//! an agent's commands reach. [`AutomationRoots`] holds the two folders. While they are in force,
//! every path a command reads goes through [`check_read`] and every path it writes through
//! [`check_write`]:
//!
//! - The path is made absolute against the working directory, as the file system reads it. Its
//! links are followed: for a file that doesn't exist yet, the links of its nearest existing
//! folder, the rest of the path being plain names (`..` below a missing folder is refused, and so
//! is a link that leads nowhere).
//! - On Windows a network path (`\\server\share`, `\\?\UNC\...`), a device path (`\\.\...`) or a
//! verbatim path that isn't a disk is refused before anything opens it, unless a root is already
//! on that same server and share (or that same device or prefix). A link whose target is one of
//! those is refused from the target text, before the link is followed. Opening such a path would
//! contact a host the agent named.
//! - The result must lie inside the root, compared by whole components (`/work2` isn't inside
//! `/work`) and exactly: both sides have been through the file system, which gives each folder
//! its real name, and a Windows folder can be case sensitive, with `Root` beside `root`.
//! - Reads may lie under either root; writes only under the write root, and never at the write
//! root itself (its save-style temporary file would be outside). A root given alone grants
//! reads under it even when it is the write root; a read root grants no writes.
//!
//! Roots are in force on a thread inside [`confine`]. The MCP headless backend runs every call in
//! it; without roots nothing is checked, so the app and the command line keep working everywhere.
//!
//! A path is checked, then opened: a process that can change the folders in between (swapping in
//! a link) can still win that race. A network, device or non-disk verbatim path is not opened at
//! all. The roots keep an agent to the files it was given; they don't guard against other
//! programs on the computer.
pub mod commands;
use std::cell::RefCell;
use std::ffi::OsString;
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
/// Read access or write access.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Access {
Read,
Write,
}
/// The folders automation may read and write; a root left out grants no access of its kind.
#[derive(Debug)]
pub struct AutomationRoots {
read: Option<PathBuf>,
write: Option<PathBuf>,
}
/// The folder at `path`, which must exist, made absolute with its links followed: what paths are
/// compared with.
fn open_root(path: &Path, access: Access) -> Result<PathBuf, String> {
let kind = match access {
Access::Read => "read",
Access::Write => "write",
};
std::fs::canonicalize(path)
.and_then(|p| if p.is_dir() { Ok(p) } else { Err(std::io::ErrorKind::NotADirectory.into()) })
.map_err(|e| format!("cannot open the automation {kind} root `{}`: {e}", path.display()))
}
impl AutomationRoots {
/// The roots `read` and `write`, which must be existing folders; `None` when neither is given
/// (nothing is confined then).
pub fn new(read: Option<&Path>, write: Option<&Path>) -> Result<Option<Arc<Self>>, String> {
if read.is_none() && write.is_none() {
return Ok(None);
}
let read = read.map(|p| open_root(p, Access::Read)).transpose()?;
let write = write.map(|p| open_root(p, Access::Write)).transpose()?;
Ok(Some(Arc::new(Self { read, write })))
}
/// The read root, absolute with its links followed.
pub fn read_root(&self) -> Option<&Path> {
self.read.as_deref()
}
/// The write root, absolute with its links followed.
pub fn write_root(&self) -> Option<&Path> {
self.write.as_deref()
}
/// May the file or folder at `path` be read (or written)? `Err` says why not.
///
/// A read may lie under either root: the read root, or the write root (files the agent may
/// write it may also read back). A write may lie only under the write root, and not at the
/// root itself, whose save-style temporary file would sit beside it. Its name must stand there
/// too: a link outside pointing in is refused, since what is written beside the name (a
/// drawing's `.bak`) or done to it (a delete) happens in the folder that holds it.
///
/// A path is taken as it is: turned into text on the way, a name that isn't text would name a
/// different file.
pub fn check(&self, given: impl AsRef<Path>, access: Access) -> Result<(), String> {
let given = given.as_ref();
let target = resolve(given, self)?;
let path = given.display();
if access == Access::Read {
let roots = [self.read.as_ref(), self.write.as_ref()];
if roots.iter().flatten().any(|r| inside(&target, r)) {
return Ok(());
}
if roots.iter().all(|r| r.is_none()) {
return Err(format!("automation filesystem access is not granted: read authority is absent: {path}"));
}
return Err(format!("automation path rejected: outside the read root (or the write root): {path}"));
}
let Some(folder) = self.write.as_ref() else {
return Err(format!("automation filesystem access is not granted: write authority is absent: {path}"));
};
if !inside(&target, folder) {
return Err(format!("automation path rejected: outside the write root {}: {path}", folder.display()));
}
// A write to the root itself would put its temporary file beside the root, outside it.
if same(&target, folder) {
return Err(format!("automation path rejected: the write root itself cannot be written: {path}"));
}
if !inside(&resolve(given.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(Path::new(".")), self)?, folder) {
return Err(format!("automation path rejected: stands outside the write root {}: {path}", folder.display()));
}
Ok(())
}
}
thread_local! {
/// The roots in force on this thread.
static ROOTS: RefCell<Option<Arc<AutomationRoots>>> = const { RefCell::new(None) };
}
/// Puts the roots it replaced back when dropped (also when `f` panics).
struct Restore(Option<Arc<AutomationRoots>>);
impl Drop for Restore {
/// Puts the roots it replaced back.
fn drop(&mut self) {
ROOTS.with(|r| *r.borrow_mut() = self.0.take());
}
}
/// Run `f` with `roots` in force on this thread (`None`: as things stand).
pub fn confine<T>(roots: Option<&Arc<AutomationRoots>>, f: impl FnOnce() -> T) -> T {
let previous = ROOTS.with(|r| r.replace(roots.cloned()));
let _restore = Restore(previous);
f()
}
/// This thread's roots, if any.
pub fn current() -> Option<Arc<AutomationRoots>> {
ROOTS.with(|r| r.borrow().clone())
}
/// May `path` be read here? Always, without roots in force.
pub fn check_read(path: impl AsRef<Path>) -> Result<(), String> {
current().map_or(Ok(()), |r| r.check(path, Access::Read))
}
/// May `path` be written here? Always, without roots in force.
pub fn check_write(path: impl AsRef<Path>) -> Result<(), String> {
current().map_or(Ok(()), |r| r.check(path, Access::Write))
}
/// `path` made absolute with its links followed; for a path that doesn't exist (yet), its nearest
/// existing folder's links followed and the rest appended.
///
/// A Windows network, device or non-disk verbatim prefix is refused before any of that, unless
/// `roots` already stands on the same server and share (or the same device or prefix).
fn resolve(path: &Path, roots: &AutomationRoots) -> Result<PathBuf, String> {
let shown = path.display();
if path.as_os_str().is_empty() {
return Err("automation path rejected: path is empty".into());
}
// Checked as given: making `…\NUL` absolute gives the device path `\\.\NUL` on Windows.
if cfg!(windows) && path.components().any(|c| matches!(c, Component::Normal(n) if n.to_str().is_some_and(is_device_name))) {
return Err(format!("automation path rejected: reserved device names are not allowed: {shown}"));
}
// Before `absolute` too: on Windows that call asks the system about the path.
if let Some(why) = refused_prefix(path, roots) {
return Err(format!("automation path rejected: {why}: {shown}"));
}
let absolute = std::path::absolute(path).map_err(|e| format!("automation path rejected: cannot resolve {shown}: {e}"))?;
if let Some(why) = refused_prefix(&absolute, roots) {
return Err(format!("automation path rejected: {why}: {shown}"));
}
// The names below the nearest existing folder, last first.
let mut missing: Vec<OsString> = vec![];
let mut at = absolute.as_path();
loop {
// A link to a network path is judged from the target text. Canonicalizing it would follow
// the link and contact that host. Only Windows has those prefixes, so other targets skip
// the walk.
#[cfg(windows)]
if let Some(why) = link_leads_to_refused_prefix(at, roots) {
return Err(format!("automation path rejected: {why}: {shown}"));
}
match std::fs::canonicalize(at) {
Ok(mut found) => {
found.extend(missing.iter().rev());
return Ok(found);
}
Err(e) => match std::fs::symlink_metadata(at) {
Ok(m) if m.file_type().is_symlink() => return Err(format!("automation path rejected: a link that leads nowhere: {shown}")),
// There, yet its real path can't be had (no permission): nothing to compare.
Ok(_) => return Err(format!("automation path rejected: cannot resolve {shown}: {e}")),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(format!("automation path rejected: cannot resolve {shown}: {e}")),
},
}
let parent = at.parent();
match (at.components().next_back(), parent) {
(Some(Component::Normal(name)), Some(parent)) => {
missing.push(name.to_os_string());
at = parent;
}
(Some(Component::ParentDir), _) => {
return Err(format!("automation path rejected: parent traversal below a folder that doesn't exist: {shown}"));
}
// Down to the root (or drive) and it doesn't exist either.
_ => {
let e = std::io::Error::from(std::io::ErrorKind::NotFound);
return Err(format!("automation path rejected: cannot resolve {shown}: {e}"));
}
}
}
}
/// Why `path` must not be opened: it is a Windows network, device or non-disk verbatim path, and
/// no root already uses that prefix. A local disk path returns `None`.
///
/// The comparison is ASCII case only, so `FileServer` matches `fileserver` and U+212A does not
/// match `k`. Matching only decides whether that host may be contacted; [`inside`] still decides
/// the folder.
fn refused_prefix(path: &Path, roots: &AutomationRoots) -> Option<&'static str> {
#[cfg(windows)]
{
let key = windows_prefix(path)?;
let allowed = [roots.read.as_ref(), roots.write.as_ref()]
.into_iter()
.flatten()
.any(|root| windows_prefix(root).is_some_and(|root_key| prefixes_match(&root_key, &key)));
if allowed { None } else { Some(key.refusal()) }
}
#[cfg(not(windows))]
{
let _ = (path, roots);
None
}
}
/// The refusal for a link in `path`, taken from the link's own text.
///
/// Folders are inspected from the root downward with [`std::fs::symlink_metadata`], which does not
/// follow a link, and the target is read with [`std::fs::read_link`]. A link to a network path is
/// therefore refused before [`std::fs::canonicalize`] would open that host, including when the
/// link is only an ancestor of the name. At most [`MAX_LINK_HOPS`] links are followed; one more,
/// or a link whose target cannot be read, is refused instead of being opened.
#[cfg(windows)]
fn link_leads_to_refused_prefix(path: &Path, roots: &AutomationRoots) -> Option<&'static str> {
follow_links(path, roots, MAX_LINK_HOPS)
}
/// [`link_leads_to_refused_prefix`], with `hops_left` links still allowed.
#[cfg(windows)]
fn follow_links(path: &Path, roots: &AutomationRoots, hops_left: usize) -> Option<&'static str> {
if let Some(why) = refused_prefix(path, roots) {
return Some(why);
}
let mut ancestors: Vec<&Path> = path.ancestors().collect();
ancestors.reverse();
for prefix in ancestors {
// A relative path's ancestor list ends at an empty name. Absolute paths, which are all
// this is called with, have no empty ancestor; skip it rather than treating it as missing.
if prefix.as_os_str().is_empty() {
continue;
}
if let Some(why) = refused_prefix(prefix, roots) {
return Some(why);
}
let Ok(meta) = std::fs::symlink_metadata(prefix) else { return None };
if !meta.file_type().is_symlink() {
continue;
}
if hops_left == 0 {
return Some("too many links");
}
let Ok(target) = std::fs::read_link(prefix) else { return Some("a link that leads nowhere") };
let joined = if target.is_absolute() {
target
} else {
match prefix.parent() {
Some(parent) if !parent.as_os_str().is_empty() => parent.join(target),
_ => target,
}
};
let rest = match path.strip_prefix(prefix) {
Ok(rest) if !rest.as_os_str().is_empty() => rest,
_ => Path::new(""),
};
let next = if rest.as_os_str().is_empty() { joined } else { joined.join(rest) };
if let Some(why) = refused_prefix(&next, roots) {
return Some(why);
}
return follow_links(&next, roots, hops_left - 1);
}
None
}
/// How many links [`link_leads_to_refused_prefix`] follows before it stops.
#[cfg(windows)]
const MAX_LINK_HOPS: usize = 40;
/// A Windows prefix that is not a local disk.
#[cfg(windows)]
enum WindowsPrefix {
/// `\\server\share` or `\\?\UNC\server\share`.
Unc(OsString, OsString),
/// `\\.\device`.
Device(OsString),
/// `\\?\` that is neither a disk nor `UNC`.
Verbatim(OsString),
}
#[cfg(windows)]
impl WindowsPrefix {
/// The error text for a path with this prefix.
fn refusal(&self) -> &'static str {
match self {
Self::Unc(_, _) => "UNC paths are refused unless a root is on the same server and share",
Self::Device(_) => "device paths are refused unless a root uses the same device",
Self::Verbatim(_) => "verbatim paths are refused unless a root uses the same prefix",
}
}
}
/// `path`'s Windows prefix when it is not a local disk.
#[cfg(windows)]
fn windows_prefix(path: &Path) -> Option<WindowsPrefix> {
use std::path::Prefix;
let Component::Prefix(prefix) = path.components().next()? else { return None };
match prefix.kind() {
Prefix::Disk(_) | Prefix::VerbatimDisk(_) => None,
Prefix::UNC(server, share) | Prefix::VerbatimUNC(server, share) => Some(WindowsPrefix::Unc(server.to_os_string(), share.to_os_string())),
Prefix::DeviceNS(device) => Some(WindowsPrefix::Device(device.to_os_string())),
Prefix::Verbatim(rest) => Some(WindowsPrefix::Verbatim(rest.to_os_string())),
}
}
/// Whether `path` may be opened because `root` already stands on the same server and share,
/// device or verbatim prefix. ASCII case only.
#[cfg(windows)]
fn prefixes_match(root: &WindowsPrefix, path: &WindowsPrefix) -> bool {
let same = |a: &std::ffi::OsStr, b: &std::ffi::OsStr| a.eq_ignore_ascii_case(b);
match (root, path) {
(WindowsPrefix::Unc(server, share), WindowsPrefix::Unc(path_server, path_share)) => same(server, path_server) && same(share, path_share),
(WindowsPrefix::Device(root_device), WindowsPrefix::Device(path_device)) => same(root_device, path_device),
(WindowsPrefix::Verbatim(root_prefix), WindowsPrefix::Verbatim(path_prefix)) => same(root_prefix, path_prefix),
_ => false,
}
}
/// Is `path` (resolved) `root` or inside it, component by component?
fn inside(path: &Path, root: &Path) -> bool {
let mut path = path.components();
root.components().all(|r| path.next() == Some(r))
}
/// Is `path` (resolved) exactly `root`, compared like [`inside`] does?
fn same(path: &Path, root: &Path) -> bool {
path.components().eq(root.components())
}
/// A Windows device name (`CON`, `NUL`, `COM1`, `LPT¹`… also with an extension or a `:`), which
/// names no file.
fn is_device_name(component: &str) -> bool {
let stem = component.split(['.', ':']).next().unwrap_or(component).trim_end_matches(' ').to_ascii_uppercase();
let numbered = |prefix: &str| {
stem.strip_prefix(prefix).is_some_and(|n| matches!(n, "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "¹" | "²" | "³"))
};
matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CLOCK$" | "CONIN$" | "CONOUT$") || numbered("COM") || numbered("LPT")
}
#[cfg(test)]
mod tests {
use super::*;
/// A folder of a test's own, removed when the test ends, also when it fails.
struct TestDir(PathBuf);
impl std::ops::Deref for TestDir {
type Target = Path;
/// The folder itself.
fn deref(&self) -> &Path {
&self.0
}
}
impl Drop for TestDir {
/// Removes the folder and all it holds; a failure here must not hide the test's own.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder of this test's own: made here, so nothing else put it there first.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cc-file-access-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// A fresh folder holding `in` (read root), `out` (write root) and `outside`.
fn folders(name: &str) -> (TestDir, Arc<AutomationRoots>) {
let base = fresh_dir(name);
for d in ["in/sub", "out", "outside", "in2"] {
std::fs::create_dir_all(base.join(d)).unwrap();
}
std::fs::write(base.join("in/a.dxf"), "0\nEOF\n").unwrap();
std::fs::write(base.join("outside/secret.dxf"), "0\nEOF\n").unwrap();
let roots = AutomationRoots::new(Some(&base.join("in")), Some(&base.join("out"))).unwrap().unwrap();
(base, roots)
}
/// `p` as a string a command would pass.
fn s(p: PathBuf) -> String {
p.to_string_lossy().into_owned()
}
/// Paths under either root may be read; writes stay inside the write root.
#[test]
fn paths_inside_the_roots_pass_and_others_dont() {
let (base, roots) = folders("inside");
assert_eq!(roots.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
assert_eq!(roots.check(s(base.join("in")), Access::Read), Ok(()), "the root itself");
assert_eq!(roots.check(s(base.join("in/sub/new.dxf")), Access::Read), Ok(()), "missing files are checked by their folder");
assert_eq!(roots.check(s(base.join("out/new/deeper/x.png")), Access::Write), Ok(()), "and by their nearest folder");
let e = roots.check(s(base.join("outside/secret.dxf")), Access::Read).unwrap_err();
assert!(e.starts_with("automation path rejected: outside the read root"), "{e}");
// Reads are allowed under the write root too; writes are not allowed under the read root.
assert_eq!(roots.check(s(base.join("out/x.png")), Access::Read), Ok(()), "the write root also grants reads");
let e = roots.check(s(base.join("in/a.dxf")), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "{e}");
}
/// A write-only root still permits reads inside it; reads outside both roots are refused.
#[test]
fn reads_are_allowed_under_either_root() {
let (base, _) = folders("either");
let write_only = AutomationRoots::new(None, Some(&base.join("out"))).unwrap().unwrap();
assert_eq!(write_only.check(s(base.join("out/new.dxf")), Access::Read), Ok(()), "a file to read back");
let e = write_only.check(s(base.join("in/a.dxf")), Access::Read).unwrap_err();
assert!(e.contains("outside the read root (or the write root)"), "{e}");
let read_only = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
assert_eq!(read_only.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
assert!(read_only.check(s(base.join("out/new.dxf")), Access::Read).is_err(), "a read root alone grants no read of another folder");
}
/// A write to the write root itself would put its `.cadcraft-tmp` file beside the root: refused.
#[test]
fn writing_to_the_write_root_itself_is_refused() {
let (base, roots) = folders("write-root");
let out = s(base.join("out"));
let sep = std::path::MAIN_SEPARATOR;
for p in [out.clone(), format!("{out}{sep}."), format!("{out}{sep}..{sep}out")] {
let e = roots.check(&p, Access::Write).unwrap_err();
assert!(e.contains("the write root itself cannot be written"), "{p}: {e}");
}
assert_eq!(roots.check(&out, Access::Read), Ok(()), "reading the root stays allowed");
assert_eq!(roots.check(s(base.join("out/new/x.png")), Access::Write), Ok(()), "a normal save inside still works");
}
/// `in2` starts like `in` and isn't inside it.
#[test]
fn a_sibling_with_the_same_prefix_is_outside() {
let (base, roots) = folders("prefix");
std::fs::write(base.join("in2/b.dxf"), "0\nEOF\n").unwrap();
assert!(roots.check(s(base.join("in2/b.dxf")), Access::Read).is_err(), "in2 is not inside in");
assert!(roots.check(format!("{}2/c.dxf", s(base.join("in"))), Access::Read).is_err());
}
/// `..` is followed where it can be, and refused below a missing folder.
#[test]
fn parent_traversal_is_resolved_or_refused() {
let (base, roots) = folders("dotdot");
let sep = std::path::MAIN_SEPARATOR;
let up = format!("{}{sep}..{sep}outside{sep}secret.dxf", s(base.join("in")));
assert!(roots.check(&up, Access::Read).unwrap_err().contains("outside the read root"), "`..` out of the root");
let back = format!("{}{sep}..{sep}a.dxf", s(base.join("in/sub")));
assert_eq!(roots.check(&back, Access::Read), Ok(()), "`..` that stays inside");
let missing = format!("{}{sep}nope{sep}..{sep}..{sep}outside{sep}x.dxf", s(base.join("out")));
let e = roots.check(&missing, Access::Write).unwrap_err();
// Windows resolves `..` by name first (so does opening the file there): then it's outside.
assert!(e.contains("parent traversal below a folder that doesn't exist") || e.contains("outside the write root"), "{e}");
}
/// A relative path means the working directory, and an empty one is refused.
#[test]
fn relative_paths_resolve_against_the_working_directory() {
let (_base, roots) = folders("relative");
// The tests' working directory is the crate's folder: not inside the roots.
assert!(roots.check("a.dxf", Access::Read).unwrap_err().contains("outside the read root"));
assert!(roots.check("", Access::Read).unwrap_err().contains("path is empty"));
}
/// A root must be a folder that exists; no roots at all confines nothing.
#[test]
fn a_missing_root_is_an_error_and_none_is_no_confinement() {
let (base, _) = folders("missing");
let e = AutomationRoots::new(Some(&base.join("nope")), None).unwrap_err();
assert!(e.starts_with("cannot open the automation read root"), "{e}");
let e = AutomationRoots::new(None, Some(&base.join("in/a.dxf"))).unwrap_err();
assert!(
e.starts_with("cannot open the automation write root")
&& e.ends_with(&std::io::Error::from(std::io::ErrorKind::NotADirectory).to_string()),
"{e}"
);
assert!(AutomationRoots::new(Some(Path::new("")), None).unwrap_err().starts_with("cannot open the automation read root ``"));
assert!(AutomationRoots::new(None, None).unwrap().is_none());
// One root alone grants only its own access.
let read_only = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
let e = read_only.check(s(base.join("in/x.dxf")), Access::Write).unwrap_err();
assert!(e.contains("write authority is absent"), "{e}");
}
/// Links are judged by where they lead, so a link out is refused and one inside is fine.
#[test]
fn links_are_followed_before_comparing() {
let (base, roots) = folders("links");
#[cfg(unix)]
let made = |target: &Path, link: &Path| std::os::unix::fs::symlink(target, link).is_ok();
#[cfg(windows)]
let made = |target: &Path, link: &Path| {
let made =
if target.is_dir() { std::os::windows::fs::symlink_dir(target, link) } else { std::os::windows::fs::symlink_file(target, link) };
made.is_ok()
};
#[cfg(not(any(unix, windows)))]
let made = |_: &Path, _: &Path| false;
// Windows needs Developer Mode or elevation to make links: nothing to test without them.
if !made(&base.join("outside/secret.dxf"), &base.join("in/leak.dxf")) {
eprintln!("skipped: symbolic links can't be made here");
return;
}
assert!(roots.check(s(base.join("in/leak.dxf")), Access::Read).unwrap_err().contains("outside the read root"), "a file link out");
assert!(made(&base.join("outside"), &base.join("out/away")));
let e = roots.check(s(base.join("out/away/new.png")), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "a folder link out: {e}");
assert!(made(&base.join("outside/gone.dxf"), &base.join("out/dangling.png")));
let e = roots.check(s(base.join("out/dangling.png")), Access::Write).unwrap_err();
assert!(e.contains("a link that leads nowhere"), "writing would create the file outside: {e}");
// A link to a folder inside the root stays inside.
assert!(made(&base.join("in/sub"), &base.join("in/alias")));
assert_eq!(roots.check(s(base.join("in/alias/x.dxf")), Access::Read), Ok(()));
// A root given through a link is the folder it leads to.
assert!(made(&base.join("in"), &base.join("in-link")));
let linked = AutomationRoots::new(Some(&base.join("in-link")), None).unwrap().unwrap();
assert_eq!(linked.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
}
/// Names are compared exactly: `Root` isn't `root`, which a case-sensitive folder can hold beside it.
#[test]
fn a_name_differing_only_in_case_is_not_the_root() {
assert!(!inside(Path::new("/w/Root/x"), Path::new("/w/root")));
assert!(!same(Path::new("/w/Root"), Path::new("/w/root")));
assert!(inside(Path::new("/w/root/x"), Path::new("/w/root")));
assert!(same(Path::new("/w/root"), Path::new("/w/root")));
}
/// The superscript ports, `COM0`, `LPT0` and the `:` form are device names.
#[test]
fn device_names_include_the_superscript_ports() {
for d in ["CON", "nul", "Com1", "LPT9.txt", "aux.dxf", "NUL ", "COM¹", "lpt³.txt", "com²", "NUL:", "con:stream", "COM0", "lpt0.txt"] {
assert!(is_device_name(d), "{d}");
}
for d in ["console.txt", "COM", "COM10", "LPT⁴", "a.nul", "nullable"] {
assert!(!is_device_name(d), "{d}");
}
}
/// A name that isn't text is checked as itself: the text of it names a file that isn't there,
/// which would pass, when the name itself is a link leading out.
#[cfg(unix)]
#[test]
fn a_name_that_is_not_text_is_judged_as_itself() {
use std::os::unix::ffi::OsStrExt;
let (base, roots) = folders("not-text");
let name = std::ffi::OsStr::from_bytes(b"a\xff.dxf");
let link = base.join("in").join(name);
// APFS and others refuse such a name: nothing to test there.
if std::os::unix::fs::symlink(base.join("outside/secret.dxf"), &link).is_err() {
eprintln!("skipped: this file system refuses a name that isn't text");
return;
}
assert!(roots.check(&link, Access::Read).is_err());
assert_eq!(roots.check(&*link.to_string_lossy(), Access::Read), Ok(()), "as text it is another file, which isn't there");
}
/// A name is judged by the folder it stands in as well as by where it leads.
#[cfg(unix)]
#[test]
fn a_link_standing_outside_the_write_root_is_refused() {
let (base, roots) = folders("entry");
std::fs::write(base.join("out/t.dxf"), "x").unwrap();
let link = base.join("outside/link.dxf");
std::os::unix::fs::symlink(base.join("out/t.dxf"), &link).unwrap();
assert!(roots.check(&link, Access::Write).unwrap_err().contains("stands outside the write root"));
assert_eq!(roots.check(&link, Access::Read), Ok(()), "reading it reads what is inside");
let inner = base.join("out/link.dxf");
std::os::unix::fs::symlink(base.join("out/t.dxf"), &inner).unwrap();
assert_eq!(roots.check(&inner, Access::Write), Ok(()));
assert_eq!(roots.check(base.join("out/new/deep/x.dxf"), Access::Write), Ok(()));
}
/// On a real case-sensitive folder, `Root` beside the root `root` is outside it.
#[cfg(windows)]
#[test]
fn a_case_sensitive_windows_folder_can_hold_a_sibling_of_the_root() {
let base = fresh_dir("sensitive");
let sensitive = std::process::Command::new("fsutil").args(["file", "setCaseSensitiveInfo"]).arg(&*base).arg("enable").output();
if !sensitive.is_ok_and(|o| o.status.success()) {
eprintln!("this runner can't make a case-sensitive folder: skipped");
return;
}
std::fs::create_dir(base.join("root")).unwrap();
std::fs::create_dir(base.join("Root")).unwrap();
std::fs::write(base.join("Root/secret.dxf"), "x").unwrap();
let roots = AutomationRoots::new(Some(&base.join("root")), Some(&base.join("root"))).unwrap().unwrap();
for p in ["Root/secret.dxf", "Root/new.dxf"] {
assert!(roots.check(s(base.join(p)), Access::Read).is_err(), "{p}");
assert!(roots.check(s(base.join(p)), Access::Write).is_err(), "{p}");
}
assert_eq!(roots.check(s(base.join("root/new.dxf")), Access::Write), Ok(()));
}
/// On an ordinary Windows folder any case finds the root, and device names are refused.
#[cfg(windows)]
#[test]
fn windows_gives_a_root_its_real_spelling_and_refuses_devices() {
let (base, roots) = folders("case");
let upper = s(base.join("IN/A.DXF"));
assert_eq!(roots.check(upper.as_str(), Access::Read), Ok(()), "{upper}");
assert_eq!(roots.check(s(base.join("In/Sub/New.dxf")), Access::Read), Ok(()));
let e = roots.check(s(base.join("out/NUL")), Access::Write).unwrap_err();
assert!(e.contains("reserved device names"), "{e}");
assert!(roots.check(s(base.join("out/com1.txt")), Access::Write).is_err());
assert!(roots.check(s(base.join("out/COM¹")), Access::Write).is_err());
assert_eq!(roots.check(s(base.join("out/console.txt")), Access::Write), Ok(()));
}
/// A network, device or non-disk verbatim path is refused before the file system is asked.
/// The error names the prefix. It is not the error canonicalize would return.
#[cfg(windows)]
#[test]
fn a_network_path_is_refused_before_it_is_opened() {
let (base, roots) = folders("unc");
let paths = [
(r"\\203.0.113.5\s\x.dwg", "UNC"),
(r"\\?\UNC\203.0.113.5\s\x.dwg", "UNC"),
(r"//203.0.113.5/s/x.dwg", "UNC"),
(r"\\host@SSL\share\x.dwg", "UNC"),
(r"\\host@SSL@443\share\x.dwg", "UNC"),
(r"\\.\PhysicalDrive0", "device path"),
(r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x.dwg", "verbatim path"),
];
for (p, kind) in paths {
for access in [Access::Read, Access::Write] {
let e = roots.check(p, access).unwrap_err();
assert!(e.starts_with("automation path rejected:"), "{p}: {e}");
assert!(e.contains(kind), "{p}: {e}");
assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{p}: {e}");
}
}
let e = roots.check(s(base.join("outside/secret.dxf")), Access::Read).unwrap_err();
assert!(e.contains("outside the read root"), "{e}");
let root = windows_prefix(Path::new(r"\\?\UNC\FileServer\Projects\work")).unwrap();
let same = windows_prefix(Path::new(r"\\fileserver\projects\a.dwg")).unwrap();
let other_share = windows_prefix(Path::new(r"\\fileserver\secret\a.dwg")).unwrap();
let other_host = windows_prefix(Path::new(r"\\203.0.113.5\Projects\a.dwg")).unwrap();
let kelvin = windows_prefix(Path::new("\\\\wor\u{212a}\\Projects\\a.dwg")).unwrap();
assert!(prefixes_match(&root, &same), "the same server and share, in either spelling");
assert!(!prefixes_match(&root, &other_share));
assert!(!prefixes_match(&root, &other_host));
assert!(!prefixes_match(&root, &kelvin), "U+212A is not k");
assert!(windows_prefix(Path::new(r"C:\Projects\a.dwg")).is_none());
assert!(windows_prefix(Path::new(r"\\?\C:\Projects\a.dwg")).is_none());
}
/// U+212A is a different folder from `k`, so a write there is outside the root and creates nothing.
#[cfg(windows)]
#[test]
fn a_kelvin_sign_is_not_a_way_out_of_the_write_root() {
let base = fresh_dir("kelvin");
let root = base.join("work");
std::fs::create_dir(&root).unwrap();
let roots = AutomationRoots::new(Some(&root), Some(&root)).unwrap().unwrap();
let sibling = base.join("wor\u{212a}").join("x.dwg");
let e = roots.check(s(sibling), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "{e}");
assert!(!base.join("wor\u{212a}").exists(), "the check must not create the folder");
assert_eq!(roots.check(s(root.join("new.dxf")), Access::Write), Ok(()));
}
/// A junction needs no extra privilege. One that leads out of the write root is outside it.
#[cfg(windows)]
#[test]
fn a_junction_out_of_the_write_root_is_refused() {
let (base, roots) = folders("junction");
let link = base.join("out").join("away");
let made = std::process::Command::new("cmd").args(["/c", "mklink", "/J"]).arg(&link).arg(base.join("outside")).status();
if !made.is_ok_and(|s| s.success()) {
eprintln!("skipped: junctions can't be made here");
return;
}
let e = roots.check(s(link.join("new.png")), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "{e}");
assert!(!base.join("outside/new.png").exists());
}
/// A link whose text names a network path is refused before that path is opened.
#[cfg(windows)]
#[test]
fn a_link_to_a_network_path_is_refused_before_it_is_followed() {
let (base, roots) = folders("unc-link");
let link = base.join("in/leak.dxf");
if std::os::windows::fs::symlink_file(r"\\203.0.113.5\s\x.dwg", &link).is_err() {
eprintln!("skipped: symbolic links can't be made here");
return;
}
let e = roots.check(link.as_path(), Access::Read).unwrap_err();
assert!(e.contains("UNC"), "{e}");
assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}");
}
/// An alternate data stream is still the file it hangs off: outside the roots it is refused.
#[cfg(windows)]
#[test]
fn an_alternate_stream_outside_the_roots_is_refused() {
let (base, roots) = folders("ads");
let e = roots.check(s(base.join("outside/secret.dxf:zone")), Access::Read).unwrap_err();
assert!(e.contains("outside the read root"), "{e}");
assert_eq!(roots.check(s(base.join("out/new.dxf:zone")), Access::Write), Ok(()));
}
/// Roots end with their scope, also when a nested scope or a panic ends it.
#[test]
fn scopes_nest_and_restore_after_a_panic() {
let (base, roots) = folders("scopes");
let outside = s(base.join("outside/secret.dxf"));
assert_eq!(check_read(&outside), Ok(()), "nothing is confined by default");
confine(Some(&roots), || {
assert!(check_read(&outside).is_err());
// A nested scope replaces the outer one and gives it back on the way out.
confine(None, || assert_eq!(check_read(&outside), Ok(())));
assert!(check_read(&outside).is_err(), "restored after the inner scope");
});
assert_eq!(check_read(&outside), Ok(()), "restored after confine");
let r = std::panic::catch_unwind(|| confine(Some(&roots), || panic!("boom")));
assert!(r.is_err());
assert_eq!(check_read(&outside), Ok(()), "restored after a panic");
assert_eq!(confine(None, || check_read(&outside)), Ok(()));
}
/// The plain device names, and names that only look like them.
#[test]
fn device_names() {
for d in ["CON", "nul", "Com1", "LPT9.txt", "aux.svg", "NUL "] {
assert!(is_device_name(d), "{d}");
}
for f in ["console", "com10", "lpt", "a.svg", "nul-x"] {
assert!(!is_device_name(f), "{f}");
}
}
}
-552
View File
@@ -1,552 +0,0 @@
//! Which commands automation may run while the automation roots are in force ([`super`]).
//!
//! The checks that hold a path to the roots sit where the file is touched, and a new command that
//! touches a file through a new route would get past them. So a command runs under the roots only
//! if it is listed here: anything else is refused, whatever it does. Adding a command to the
//! registry means adding it to one of these lists (`every_command_is_classified` says so).
/// Commands that read or write files, each path held to the roots where the file is touched.
pub const FILES: &[&str] = &[
"-linetype",
"-plottermanager",
"-wblock",
"-xref",
"aliasedit",
"appload",
"attach",
"blocklibimport",
"blocklibrary",
"audit",
"compare",
"compareexport",
"dataextraction",
"datalink",
"datalinkupdate",
"eattext",
"export",
"exportpdf",
"hatch",
"hatch.patterns",
"image",
"imageattach",
"import",
"insert",
"layout",
"layout.saveas",
"linetype",
"lisp",
"minsert",
"new",
"open",
"options",
"pagesetup",
"pdfbook",
"plot",
"plotstyle",
"plottermanager",
"preview",
"publish",
"qsave",
"recover",
"reinit",
"saveas",
"script",
"setvar",
"share",
"stylesmanager",
"tableexport",
"wblock",
"xattach",
"xbind",
"xopen",
"xref",
];
/// Commands that can't be held to the roots, and why.
pub const REFUSED: &[(&str, &str)] = &[
("drawingrecovery", "it works on the autosave folder (SAVEFILEPATH), which is the server's own"),
("blocklibraries", "it keeps its list of libraries in the settings folder, which is the server's own"),
];
/// Commands that touch no file.
pub const NO_FILES: &[&str] = &[
"blockspalette",
"dimoverride.clear",
"-dimstyle",
"dimstyle.overrides",
"dimstyle.saveas",
"properties.describe",
"close",
"closeall",
"document.switch",
"document.bytes",
"u",
"undo",
"redo",
"mredo",
"cutclip",
"cutbase",
"copyclip",
"copybase",
"pasteclip",
"pasteblock",
"pasteorig",
"erase.selection",
"selectall",
"ai_deselect",
"select",
"qselect",
"qselect.info",
"selectsimilar",
"isolateobjects",
"hideobjects",
"unisolateobjects",
"xclip",
"xclipframe",
"zoom",
"zoom.realtime",
"zoom.dynamic",
"zoom.previous",
"zoom.window",
"zoom.in",
"zoom.out",
"zoom.all",
"zoom.extents",
"zoom.object",
"pan",
"pan.left",
"pan.right",
"pan.up",
"pan.down",
"regen",
"regenall",
"redraw",
"dview",
"view.set",
"view.get",
"layout.set",
"view",
"-vports",
"vports.activate",
"vports.named",
"line",
"pline",
"circle",
"arc",
"rectang",
"polygon",
"ellipse",
"point",
"point.multiple",
"xline",
"ray",
"spline",
"donut",
"solid",
"text",
"mtext",
"arc.sce",
"arc.sca",
"arc.scl",
"arc.sea",
"arc.sed",
"arc.ser",
"arc.cse",
"arc.csa",
"arc.csl",
"arc.continue",
"circle.cd",
"circle.2p",
"circle.3p",
"circle.ttr",
"circle.ttt",
"ellipse.axis",
"ellipse.arc",
"divide",
"measure",
"revcloud",
"revcloud.polygonal",
"revcloud.freehand",
"wipeout",
"3dpoly",
"helix",
"spline.cv",
"centermark",
"centerline",
"mline",
"mlstyle",
"mledit",
"breakline",
"dimlinear",
"dimaligned",
"dimradius",
"dimdiameter",
"dimangular",
"dimarc",
"dimordinate",
"dimcontinue",
"dimbaseline",
"qdim",
"dim",
"mleader",
"leader",
"dimstyle.update",
"dimoverride",
"dimreassociate",
"dimdisassociate",
"dimtedit.home",
"dimtedit.angle",
"dimtedit.left",
"dimtedit.center",
"dimtedit.right",
"dimtedit",
"dimspace",
"dimedit",
"dimedit.oblique",
"dimjogged",
"dimjogline",
"dimbreak",
"diminspect",
"mleaderedit",
"mleaderedit.add",
"mleaderedit.remove",
"mleaderalign",
"mleadercollect",
"scalelistedit",
"objectscale",
"aiobjectscaleadd",
"aiobjectscaleremove",
"annoreset",
"annoupdate",
"annovisible.current",
"annovisible.all",
"annovisible.toggle",
"gradient",
"boundary",
"region",
"hatchedit",
"hatchpick",
"overkill",
"block",
"-block",
"attdef",
"attedit",
"-attedit",
"base",
"blocks.dynamic",
"blocks.reference",
"blocks.reference.set",
"blocks.reference.grips",
"blocks.reference.grip",
"purge",
"blocks.list",
"battman",
"attdisp",
"attsync",
"burst",
"blockreplace",
"blocks.description",
"attdisp.normal",
"attdisp.on",
"attdisp.off",
"refedit",
"refset",
"refclose",
"bedit",
"bsave",
"bsaveas",
"bclose",
"erase",
"oops",
"move",
"copy",
"rotate",
"scale",
"mirror",
"stretch",
"offset",
"trim",
"extend",
"fillet",
"chamfer",
"explode",
"break",
"breakatpoint",
"join",
"draworder",
"draworder.front",
"draworder.back",
"draworder.above",
"draworder.under",
"texttofront",
"texttofront.text",
"texttofront.dimensions",
"texttofront.leaders",
"texttofront.all",
"hatchtoback",
"array",
"arrayrect",
"arraypolar",
"-array",
"arrayedit",
"arrayclose",
"pedit",
"splinedit",
"lengthen",
"align",
"blend",
"reverse",
"ncopy",
"mocoro",
"chspace",
"flatten",
"arraypath",
"textedit",
"group",
"ungroup",
"groupedit",
"groups.list",
"-group",
"pickstyle",
"grip.move",
"grip.stretch",
"grip.rotate",
"grip.scale",
"grip.mirror",
"grip.option",
"grip",
"compare.next",
"compare.previous",
"compareclose",
"layer",
"layer.new",
"layer.set",
"layer.current",
"layer.delete",
"laymcur",
"laymch",
"laycur",
"layiso",
"layuniso",
"layfrz",
"layoff",
"laylck",
"layulk",
"layon",
"laythw",
"layerp",
"layerstate.save",
"layerstate.restore",
"layerstate.list",
"layerstate.delete",
"layerstate.rename",
"laymrg",
"laydel",
"layout.new",
"layout.delete",
"layout.rename",
"layout.copy",
"layout.list",
"mview",
"mview.polygonal",
"vpclip",
"vports",
"vports.1",
"vports.2",
"vports.3",
"vports.4",
"viewport.set",
"vplayer",
"mspace",
"pspace",
"plotwindow",
"3dorbit",
"properties",
"properties.set",
"chprop",
"change",
"matchprop",
"color",
"lweight",
"ltscale",
"units",
"-units",
"thickness",
"limits",
"style",
"style.list",
"style.rename",
"style.delete",
"style.current",
"dimstyle",
"dimstyle.dimension",
"dimstyle.list",
"dimstyle.rename",
"dimstyle.delete",
"dimstyle.current",
"dimstyle.override",
"tablestyle",
"mleaderstyle",
"ddptype",
"rename",
"dist",
"id",
"list",
"area",
"time",
"status",
"drawing.inspect",
"entities",
"shapes",
"usage",
"loops",
"texts",
"countlist",
"counttable",
"count",
"union",
"subtract",
"intersect",
"massprop",
"ortho",
"grid",
"snap",
"polar",
"otrack",
"dynmode",
"lwdisplay",
"isodraft",
"isoplane",
"transparencydisplay",
"qpmode",
"selectioncycling",
"osnap",
"dsettings",
"getvar",
"sysvars",
"cal",
"quickcalc.pick",
"find",
"measuregeom",
"radius.measure",
"angle.measure",
"volume.measure",
"table",
"table.set",
"table.insertrow",
"table.deleterow",
"table.insertcol",
"table.deletecol",
"table.merge",
"table.unmerge",
"tablestyle.cellstyle",
"table.cellstyle",
"table.formula",
"table.recalc",
"tabledit",
"table.break",
"tolerance",
"txt2mtxt",
"geomconstraint",
"gccoincident",
"gcperpendicular",
"gcparallel",
"gctangent",
"gchorizontal",
"gcvertical",
"gccollinear",
"gcconcentric",
"gcsmooth",
"gcsymmetric",
"gcequal",
"gcfix",
"autoconstrain",
"constraintbar",
"constraintbar.showall",
"constraintbar.hideall",
"dimconstraint",
"dcaligned",
"dchorizontal",
"dcvertical",
"dcangular",
"dcradius",
"dcdiameter",
"dclinear",
"dcdisplay",
"dcdisplay.showall",
"dcdisplay.hideall",
"delconstraint",
"parameters",
"constraintsettings",
"constraintinfer",
"constraints.inspect",
"constraints.dof",
];
/// Why command `id` may not run here; `None` when it may. Without roots in force everything may.
pub fn refusal(id: &str) -> Option<String> {
super::current()?;
if let Some((_, why)) = REFUSED.iter().find(|(c, _)| *c == id) {
return Some(format!("automation command refused: {why}"));
}
if FILES.contains(&id) || NO_FILES.contains(&id) {
return None;
}
Some("automation command refused: it is not classified for the automation roots".to_string())
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic)]
mod tests {
use super::super::{AutomationRoots, confine};
use super::*;
use std::collections::BTreeSet;
/// Words in a command's parameter doc that usually name a file. In these commands they don't:
/// `array` and `arraypath` follow a path of objects, and `blocks.reference.grips` reports a
/// direction.
const NOT_FILES: &[&str] = &["array", "arraypath", "blocks.reference.grips"];
/// The words of a command's documentation, lower case.
fn words(doc: &str) -> BTreeSet<String> {
doc.to_ascii_lowercase().split(|c: char| !c.is_ascii_alphanumeric()).map(str::to_string).collect()
}
/// Walks the registry: every command is on exactly one list, and the lists name no command
/// that is gone. A command whose parameters name a file can't be on the no-files list.
#[test]
fn every_command_is_classified() {
let refused: Vec<&str> = REFUSED.iter().map(|(c, _)| *c).collect();
let lists = [FILES, refused.as_slice(), NO_FILES];
let specs = crate::command_specs();
for spec in specs {
let on = lists.iter().filter(|l| l.contains(&spec.id)).count();
assert_eq!(on, 1, "`{}` is on {on} lists: add it to one in file_access/commands.rs", spec.id);
let doc = words(spec.params);
let names_a_file = ["path", "file", "template", "patternfile", "folder", "dir"].iter().any(|w| doc.contains(*w));
if names_a_file && NO_FILES.contains(&spec.id) && !NOT_FILES.contains(&spec.id) {
panic!("`{}` takes a file ({}): it belongs on FILES, with its paths checked", spec.id, spec.params);
}
}
for id in lists.iter().flat_map(|l| l.iter()) {
assert!(specs.iter().any(|s| s.id == *id), "`{id}` is listed but no longer a command");
}
}
/// Under roots a command nobody classified is refused; without roots it isn't this table's business.
#[test]
fn an_unclassified_command_fails_closed() {
let base = std::env::temp_dir().join(format!("cc-commands-{}", std::process::id()));
std::fs::create_dir_all(&base).unwrap();
let roots = AutomationRoots::new(Some(&base), None).unwrap();
assert_eq!(refusal("made.up"), None);
confine(roots.as_ref(), || {
assert!(refusal("made.up").unwrap().contains("not classified"));
assert!(refusal("drawingrecovery").unwrap().contains("autosave"));
assert!(refusal("blocklibraries").unwrap().contains("settings folder"));
assert_eq!(refusal("open"), None);
assert_eq!(refusal("line"), None);
});
let _ = std::fs::remove_dir_all(base);
}
}
-1
View File
@@ -18,7 +18,6 @@ pub mod blockedit;
pub mod capped_read;
pub mod cmd;
pub mod doc_path;
pub mod file_access;
mod finite;
pub mod grip_dims;
pub mod grips;
+11 -6
View File
@@ -139,6 +139,9 @@ pub struct LispState {
/// Interpreter steps all synchronous callbacks have run, nested ones included. A callback's
/// allowance counts what ran since it started, so the callbacks it calls spend its steps.
pub(crate) callback_used: u64,
/// Work synchronous callbacks did inside the running step, already counted in `callback_used`:
/// the step is charged it without charging the enclosing callback a second time.
pub(crate) callback_work: u64,
/// The `callback_used` value the callback running now (and so every one it calls) must not
/// pass: the lowest of its own and its callers' allowances.
pub(crate) callback_ceiling: Option<u64>,
@@ -383,6 +386,14 @@ impl Session {
let uid = run.uid;
self.lisp_flush(&mut env, false);
self.lisp_env_put(uid, env);
// The work the slice did, which one step can take far past the slice. After a panic
// `used` is still the previous slice's; the run ends with the error anyway.
run.steps = run.steps.saturating_add(run.machine.used);
if run.blocking && run.steps > BLOCKING_CAP && matches!(outcome, Outcome::Wait(_)) {
self.lisp.run = Some(run);
self.lisp_error(LispError::quit(format!("routine stopped after {BLOCKING_CAP} steps")));
return;
}
match outcome {
Outcome::Done(v) => {
self.lisp.run = Some(run);
@@ -395,13 +406,7 @@ impl Session {
return;
}
Outcome::Wait(Need::Yield) => {
run.steps = run.steps.saturating_add(SLICE);
if run.blocking {
if run.steps > BLOCKING_CAP {
self.lisp.run = Some(run);
self.lisp_error(LispError::quit(format!("routine stopped after {BLOCKING_CAP} steps")));
return;
}
self.lisp.run = Some(run);
continue;
}
+2 -9
View File
@@ -13,7 +13,6 @@ pub struct LispFile {
pub text: String,
}
/// LISP `open`: a file handle, or nil when the file can't be opened or the automation roots refuse it.
pub(super) fn open(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 2, 3)?;
let path = string(&a[0])?.to_string();
@@ -39,7 +38,7 @@ pub(super) fn open(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError>
}
None => return Ok(Flow::Value(Value::Nil)),
}
} else if crate::file_access::check_write(&path).is_err() || !can_write(&path) {
} else if !can_write(&path) {
return Ok(Flow::Value(Value::Nil));
}
let id = ctx.env.next_file;
@@ -84,7 +83,6 @@ pub fn read_text_file(path: impl AsRef<std::path::Path>) -> Option<String> {
// Read through a byte-limited, regular-file-only reader so a path naming an endless device
// cannot exhaust memory before the 64 MiB cap is enforced (CWE-400).
const MAX: usize = 64 * 1024 * 1024;
crate::file_access::check_read(path.as_ref()).ok()?;
let bytes = crate::capped_read::read_capped(path.as_ref(), MAX).ok()?;
Some(String::from_utf8_lossy(&bytes).into_owned())
}
@@ -105,13 +103,9 @@ fn can_write(_path: &str) -> bool {
false
}
/// Write or append `text`, doing nothing when the automation roots refuse the path.
#[cfg(not(target_arch = "wasm32"))]
fn write_text_file(path: &str, text: &str, append: bool) {
use std::io::Write;
if crate::file_access::check_write(path).is_err() {
return;
}
// Opened without blocking and without truncating, so a FIFO with no reader fails at once
// instead of stalling the interpreter; only a regular file is then truncated and written.
let mut o = std::fs::OpenOptions::new();
@@ -133,11 +127,10 @@ fn write_text_file(path: &str, text: &str, append: bool) {
fn write_text_file(_path: &str, _text: &str, _append: bool) {}
/// A file or a folder: routines test whether a module is installed with `(findfile "module/.")`.
/// Outside the automation roots the answer is no.
#[cfg(not(target_arch = "wasm32"))]
fn file_exists(path: &str) -> bool {
let p = std::path::Path::new(path);
crate::file_access::check_read(p).is_ok() && (p.is_file() || p.is_dir())
p.is_file() || p.is_dir()
}
#[cfg(target_arch = "wasm32")]
+1 -5
View File
@@ -64,11 +64,7 @@ pub(super) fn list(a: &[Value]) -> R {
pub(super) fn append(a: &[Value]) -> R {
let mut items = Vec::new();
for v in a {
let l = list_arg(v)?;
// Check the result's cells before holding them: the same long list given many times
// would otherwise grow far past the cell cap inside this one call (#1930).
super::super::value::check_new_cells(items.len().saturating_add(l.len()))?;
items.extend(l);
items.extend(list_arg(v)?);
}
Ok(Value::list(items))
}
+4 -17
View File
@@ -1228,23 +1228,10 @@ pub fn load_source(s: &Session, name: &str) -> Option<String> {
}
let candidates =
if std::path::Path::new(name).extension().is_none() { vec![format!("{name}.lsp"), name.to_string()] } else { vec![name.to_string()] };
// An absolute path is read as given. A relative name is looked up in the support folder only,
// never in the process working folder: that can be the folder of a drawing just opened from a
// file manager, and a `tools.lsp` shipped beside it must not answer a startup file's
// `(load "tools")` (#1927). Without a support folder (the command-line tool, which has no
// startup files) a relative name is read as given.
let dir = match s.lisp_support_dir() {
Some(d) if !std::path::Path::new(name).is_absolute() => d,
_ => return candidates.iter().find_map(super::builtins::read_text_file),
};
// A relative name stays inside the support folder: plain folder and file names only. `..` would
// climb out of it, and on Windows a rooted name (`\tools`) or a drive-relative one (`C:tools`,
// the working folder of drive C) is not absolute, yet joined to the folder it replaces it.
use std::path::Component;
if !std::path::Path::new(name).components().all(|c| matches!(c, Component::Normal(_) | Component::CurDir)) {
return None;
}
candidates.iter().find_map(|c| super::builtins::read_text_file(dir.join(c)))
// As given (a path, or relative to the working folder), then in the support folder.
let support =
s.lisp_support_dir().map(|d| candidates.iter().map(|c| d.join(c).to_string_lossy().into_owned()).collect::<Vec<_>>()).unwrap_or_default();
candidates.iter().chain(&support).find_map(super::builtins::read_text_file)
}
#[cfg(test)]
+41 -8
View File
@@ -175,17 +175,19 @@ pub struct Machine {
stack: Vec<Frame>,
state: State,
need: Option<Need>,
/// Steps the last [`Machine::run`] took, with the work done inside them.
pub(crate) used: u64,
}
impl Machine {
/// A machine evaluating `forms` in turn.
pub fn forms(forms: Vec<Value>) -> Machine {
Machine { stack: vec![Frame::Forms { rest: forms.into_iter().rev().collect() }], state: State::Ret(Value::Nil), need: None }
Machine { stack: vec![Frame::Forms { rest: forms.into_iter().rev().collect() }], state: State::Ret(Value::Nil), need: None, used: 0 }
}
/// A machine calling `f` with `args`.
pub fn calling(f: Value, args: Vec<Value>) -> Machine {
Machine { stack: Vec::new(), state: State::Call(f, args), need: None }
Machine { stack: Vec::new(), state: State::Call(f, args), need: None, used: 0 }
}
/// Give the value a [`Need`] waited for, and carry on.
@@ -193,12 +195,31 @@ impl Machine {
self.state = State::Ret(v);
}
/// Run until done, waiting, or `budget` steps.
/// Run until done, waiting, or `budget` steps. A step that walks a long list (`length`) or
/// runs a synchronous callback counts that work too, so one slice stays short.
pub fn run(&mut self, ctx: &mut Ctx<'_>, budget: u64) -> Outcome {
let mut n = 0u64;
let outcome = self.run_counted(ctx, budget, &mut n);
// The last step's work too, so nothing is left for the next run.
self.used = n.saturating_add(Machine::take_step_work(ctx));
outcome
}
/// The work the last step did besides itself: the lists it walked, which count against a
/// callback's allowance too, and the callbacks it ran, which were counted there as they ran.
fn take_step_work(ctx: &mut Ctx<'_>) -> u64 {
let walked = super::value::take_work();
let callbacks = std::mem::take(&mut ctx.s.lisp.callback_work);
if ctx.depth > 0 {
ctx.s.lisp.callback_used = ctx.s.lisp.callback_used.saturating_add(walked);
}
walked.saturating_add(callbacks)
}
fn run_counted(&mut self, ctx: &mut Ctx<'_>, budget: u64, n: &mut u64) -> Outcome {
loop {
n += 1;
if n > budget {
*n = n.saturating_add(1).saturating_add(Machine::take_step_work(ctx));
if *n > budget {
return Outcome::Wait(Need::Yield);
}
// Charge a callback's step as it runs, so callbacks it calls see what it already spent.
@@ -651,6 +672,10 @@ impl Ctx<'_> {
return Ok(v);
}
let cap = self.s.lisp.limits.callback_steps;
// Work the caller queued before this call (its list walks, earlier callbacks of the same
// step) is not this callback's: set it aside and hand it back with this callback's.
let pending = super::value::take_work();
let pending_callbacks = std::mem::take(&mut self.s.lisp.callback_work);
let start = self.s.lisp.callback_used;
// This callback may run until `callback_used` reaches `ceiling`: `cap` steps from now, or
// sooner where a caller's allowance ends, so callbacks nested in callbacks share one
@@ -658,13 +683,20 @@ impl Ctx<'_> {
let outer = self.s.lisp.callback_ceiling;
let ceiling = start.saturating_add(cap).min(outer.unwrap_or(u64::MAX));
self.s.lisp.callback_ceiling = Some(ceiling);
let r = self.drive_callback(f, args, ceiling);
let mut spent: u64 = 0;
let r = self.drive_callback(f, args, ceiling, &mut spent);
self.s.lisp.callback_ceiling = outer;
super::value::charge_work(pending);
// Its steps, nested callbacks' included, are work done inside the caller's one step: they
// count against the caller's slice and every enclosing callback's. They are in
// `callback_used` already, so they reach the caller apart from its list walks.
self.s.lisp.callback_work = pending_callbacks.saturating_add(spent);
r
}
/// Run callback `f` in slices until it finishes or `callback_used` reaches `ceiling`.
fn drive_callback(&mut self, f: &Value, args: Vec<Value>, ceiling: u64) -> Result<Value, LispError> {
/// Run callback `f` in slices until it finishes or `callback_used` reaches `ceiling`, adding
/// the work each slice did to `spent`.
fn drive_callback(&mut self, f: &Value, args: Vec<Value>, ceiling: u64, spent: &mut u64) -> Result<Value, LispError> {
let cap = self.s.lisp.limits.callback_steps;
let mut m = Machine::calling(f.clone(), args);
let mut sub = Ctx { s: &mut *self.s, env: &mut *self.env, depth: self.depth + 1 };
@@ -680,6 +712,7 @@ impl Ctx<'_> {
}
let slice = remaining.min(SYNC_SLICE);
let outcome = m.run(&mut sub, slice);
*spent = spent.saturating_add(m.used);
match outcome {
// The steps were charged as they ran; finishing past the shared allowance is a failure too.
Outcome::Done(_) if sub.s.lisp.callback_used > ceiling => {
+106 -71
View File
@@ -247,6 +247,112 @@ fn synchronous_callback_loop_is_an_error_not_a_hang() {
assert_eq!(ok(&mut s, "(vl-sort '(3 1 2) '<)"), "(1 2 3)");
}
/// A step that walks a long list counts its work: one `length` of 32768 cells is past a 1000-step
/// slice, so the slice yields after it.
#[test]
fn walking_a_long_list_counts_against_the_slice() {
use super::eval::{Ctx, Machine, Need, Outcome};
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
let mut s = session();
let mut env = super::Env::default();
let mut ctx = Ctx { s: &mut s, env: &mut env, depth: 0 };
// Built before the measured run, so only the `length` is counted.
let mut build = Machine::forms(super::read::read_all("(setq l '(1)) (repeat 15 (setq l (append l l)))").unwrap());
assert!(matches!(build.run(&mut ctx, u64::MAX), Outcome::Done(_)));
let mut m = Machine::forms(super::read::read_all("(length l)").unwrap());
// Counted as one step, the walk left the few steps of `(length l)` well inside the slice.
assert!(matches!(m.run(&mut ctx, 1_000), Outcome::Wait(Need::Yield)), "the walk was not charged");
assert!(m.used > 32_768, "{}", m.used);
match m.run(&mut ctx, u64::MAX) {
Outcome::Done(v) => assert_eq!(to_text(&v, true), "32768"),
_ => panic!("the length did not finish"),
}
assert_eq!(super::value::take_work(), 0, "nothing is left for the next run");
}
/// A routine is charged the work its slice did, not the slice's length: one `length` of 2^19
/// cells is far past a 400000-step slice.
#[test]
fn a_routine_is_charged_the_work_of_its_slice() {
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
let mut s = session();
ok(&mut s, "(setq l '(1)) (repeat 19 (setq l (append l l))) nil");
let r = s.lisp_eval("(length l) (repeat 10 (setq x 1))", false, false, Vec::new()).unwrap();
assert!(r.is_none(), "the routine gave the interface a frame");
assert!(s.lisp_busy());
let steps = s.lisp.run.as_ref().map(|r| r.steps).unwrap_or(0);
assert!(steps >= 1 << 19, "{steps}");
for _ in 0..100 {
if !s.lisp_busy() {
break;
}
s.lisp_tick();
}
assert!(!s.lisp_running());
ok(&mut s, "(setq l nil)");
}
/// A run's last step walking a long list is charged to that run, not left for the next one: here
/// it fails after the walk (a list of numbers isn't a list of strings), so no step follows it.
#[test]
fn the_last_steps_list_walk_is_charged_to_its_run() {
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
let mut s = session();
let mut env = super::Env::default();
env.globals.insert(super::value::Sym::new("L"), Value::list(vec![Value::Int(1); 100_000]));
let mut m = super::eval::Machine::forms(super::read::read_all("(acad_strlsort l)").unwrap());
let mut ctx = super::eval::Ctx { s: &mut s, env: &mut env, depth: 0 };
assert!(matches!(m.run(&mut ctx, u64::MAX), super::eval::Outcome::Error(_)));
assert!(m.used > 100_000, "{}", m.used);
assert_eq!(super::value::take_work(), 0, "nothing is left for the next run");
}
/// Nested callbacks share one cap: an inner endless callback retried by an outer one stops.
#[test]
fn nested_callback_steps_count_against_the_outer_callback() {
let mut s = session();
s.lisp.limits.callback_steps = 10_000;
// Each level retried the endless level inside it with a fresh cap: 10000^3 steps, a hang.
let code = "(defun g (a b) (while t)) \
(defun f (a b) (while t (vl-catch-all-apply 'vl-sort (list '(1 2) 'g)))) \
(defun h (a b) (while t (vl-catch-all-apply 'vl-sort (list '(1 2) 'f)))) \
(vl-sort '(1 2) 'h)";
assert_eq!(eval(&mut s, code), Err("callback stopped after 10000 steps".into()));
// A callback's own steps count once, however many slices it runs in: three slices do three
// times the work of one.
let counts: Vec<u64> = [400_000, 1_200_000]
.into_iter()
.map(|cap| {
s.lisp.limits.callback_steps = cap;
ok(&mut s, "(setq n 0)");
assert!(eval(&mut s, "(vl-remove-if '(lambda (x) (while t (setq n (1+ n)))) '(1))").is_err());
ok(&mut s, "n").parse().unwrap()
})
.collect();
assert!(counts[1] * 10 >= counts[0] * 29, "{counts:?}");
}
/// The callback cap holds for each callback: a sort's comparisons together take more steps than
/// it, and all their work still reaches the enclosing run.
#[test]
fn each_callback_has_its_own_cap_and_its_work_reaches_the_caller() {
let mut s = session();
s.lisp.limits.callback_steps = 1_000;
let mut env = super::Env::default();
env.globals.insert(super::value::Sym::new("L"), Value::list((0..300).rev().map(Value::Int)));
let mut m = super::eval::Machine::forms(super::read::read_all("(vl-sort l (function (lambda (a b) (< a b))))").unwrap());
let mut ctx = super::eval::Ctx { s: &mut s, env: &mut env, depth: 0 };
let v = match m.run(&mut ctx, u64::MAX) {
super::eval::Outcome::Done(v) => v,
super::eval::Outcome::Error(e) => panic!("the sort failed: {e:?}"),
super::eval::Outcome::Wait(_) => panic!("the sort waited"),
};
assert_eq!(to_text(&v, true), to_text(&Value::list((0..300).map(Value::Int)), true));
// Over a thousand comparisons of several steps each, together well past the cap.
assert!(m.used > 3_000, "{}", m.used);
assert_eq!(super::value::take_work(), 0, "nothing is left for the next run");
}
/// A zero-step callback limit prevents even the first callback side effect.
#[test]
fn a_zero_callback_budget_does_not_run_the_callback() {
@@ -1480,74 +1586,3 @@ fn atof_out_of_range_exponent_reads_whole_token() {
assert_eq!(ok(&mut s, "(< (atof \"-1e400\") -1e300)"), "T");
assert_eq!(ok(&mut s, "(= (atof \"1e-400\") 0.0)"), "T");
}
/// #1927: with a support folder, a relative `load` name is found there, never through the
/// process working folder; an absolute path is still read as given.
#[cfg(unix)]
#[test]
fn relative_load_uses_the_support_folder_not_the_working_folder() {
let base = std::env::temp_dir().join(format!("cadcraft-lisp-loadpath-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
let (support, other) = (base.join("support"), base.join("other"));
std::fs::create_dir_all(&support).unwrap();
std::fs::create_dir_all(&other).unwrap();
std::fs::write(support.join("tools.lsp"), "(setq which \"support\")").unwrap();
std::fs::write(other.join("tools.lsp"), "(setq which \"other\")").unwrap();
std::fs::write(other.join("only.lsp"), "(setq only 1)").unwrap();
// `other/…` as a path relative to the working folder.
let cwd = std::env::current_dir().unwrap();
let up = "../".repeat(cwd.components().count().saturating_sub(1));
let rel = |f: &str| format!("{up}{}", other.join(f).to_string_lossy().trim_start_matches('/'));
let mut s = session();
s.set_lisp_support_dir(Some(support.clone()));
assert_eq!(ok(&mut s, "(load \"tools\") which"), "\"support\"");
let r = eval(&mut s, &format!("(load \"{}\") only", rel("only.lsp")));
assert!(!matches!(r.as_deref(), Ok("1")), "not read through the working folder: {r:?}");
assert_eq!(ok(&mut s, &format!("(load \"{}\") which", other.join("tools.lsp").to_string_lossy())), "\"other\"");
let _ = std::fs::remove_dir_all(&base);
}
/// #1927 on Windows: a rooted name (`\folder\tools.lsp`, no drive) or a drive-relative one
/// (`C:tools`) is not absolute, but joined to the support folder it replaces that folder; such a
/// name is refused rather than read from outside the support folder.
#[cfg(windows)]
#[test]
fn rooted_and_drive_relative_load_names_stay_in_the_support_folder() {
let base = std::env::temp_dir().join(format!("cadcraft-lisp-rooted-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
let (support, other) = (base.join("support"), base.join("other"));
std::fs::create_dir_all(&support).unwrap();
std::fs::create_dir_all(&other).unwrap();
let outside = other.join("only.lsp");
std::fs::write(&outside, "(setq only 1)").unwrap();
// The same file without its drive (`\Users\...\other\only.lsp`), escaped for a LISP string.
let full = outside.to_string_lossy().into_owned();
let rooted = full.get(full.find('\\').unwrap()..).unwrap().replace('\\', "\\\\");
let drive = full.get(..2).unwrap().to_string();
let mut s = session();
s.set_lisp_support_dir(Some(support.clone()));
let r = eval(&mut s, &format!("(load \"{rooted}\") only"));
assert!(!matches!(r.as_deref(), Ok("1")), "a rooted name is not read outside the support folder: {r:?}");
let r = eval(&mut s, &format!("(load \"{drive}only\") only"));
assert!(!matches!(r.as_deref(), Ok("1")), "a drive-relative name is refused: {r:?}");
std::fs::write(support.join("only.lsp"), "(setq only 2)").unwrap();
assert_eq!(ok(&mut s, "(load \".\\\\only\") only"), "2", "a plain relative name is still read from the support folder");
let _ = std::fs::remove_dir_all(&base);
}
/// #1930: `append` over many references to one long list is refused before it builds the
/// result, not after it has filled memory.
#[test]
fn append_checks_the_cell_cap_before_building_its_result() {
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
let mut s = session();
s.lisp.limits.cells = 50_000;
let before = super::value::live_cells();
let e =
eval(&mut s, "(setq l nil) (repeat 10000 (setq l (cons 1 l))) (setq m nil) (repeat 1000 (setq m (cons l m))) (apply 'append m)").unwrap_err();
assert!(e.contains("too many list cells"), "{e}");
assert!(super::value::live_cells() < before + 50_000, "no oversized result was built");
assert_eq!(ok(&mut s, "(setq l nil m nil) (length (append '(1) '(2 3)))"), "3");
}
+15 -5
View File
@@ -64,6 +64,8 @@ thread_local! {
static STRING_BYTES: Cell<(u64, u64)> = const { Cell::new((0, STRING_BUDGET)) };
/// The running slice's cap on live cons cells.
static CELL_LIMIT: Cell<usize> = const { Cell::new(MAX_CELLS) };
/// Work done inside the current machine step: list cells walked, steps of synchronous callbacks.
static WORK: Cell<u64> = const { Cell::new(0) };
}
/// Start a slice of a run on this thread: it fails when more than `limit` cells are alive.
@@ -76,10 +78,14 @@ pub fn check_cells() -> Result<(), LispError> {
if live_cells() > CELL_LIMIT.with(Cell::get) { Err(LispError::quit("out of memory: too many list cells")) } else { Ok(()) }
}
/// `n` more cons cells would exceed the cap: checked before a built-in allocates a result many
/// times the size of its arguments (`append` over the same long list, #1930).
pub fn check_new_cells(n: usize) -> Result<(), LispError> {
if live_cells().saturating_add(n) > CELL_LIMIT.with(Cell::get) { Err(LispError::quit("out of memory: too many list cells")) } else { Ok(()) }
/// Count `n` units of work done inside one machine step ([`super::eval::Machine::run`] charges them as steps).
pub fn charge_work(n: u64) {
WORK.with(|c| c.set(c.get().saturating_add(n)));
}
/// The work counted since the last call.
pub fn take_work() -> u64 {
WORK.with(|c| c.replace(0))
}
/// Start a slice of a run on this thread: it has made `used` bytes of its `budget`.
@@ -268,7 +274,10 @@ impl Value {
loop {
match v {
Value::Nil => return true,
Value::Cons(c) => v = c.cdr.clone(),
Value::Cons(c) => {
charge_work(1);
v = c.cdr.clone();
}
_ => return false,
}
}
@@ -324,6 +333,7 @@ impl Iterator for ListIter {
fn next(&mut self) -> Option<Value> {
match std::mem::take(&mut self.next) {
Value::Cons(c) => {
charge_work(1);
self.next = c.cdr.clone();
Some(c.car.clone())
}
-4
View File
@@ -24,12 +24,8 @@ impl Session {
}
}
/// Run a command by id, unless the automation roots, its own state or the block editor refuse it.
fn execute_guarded(&mut self, id: &str, params: &Value) -> Result<Value> {
let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
if let Some(why) = crate::file_access::commands::refusal(spec.id) {
return Err(EngineError::Disabled(spec.id.into(), why));
}
(spec.enabled)(self).map_err(|m| EngineError::Disabled(spec.id.into(), m))?;
if let Some(why) = cmd::blocks::bedit::refused_in_editor(self, spec.id) {
return Err(EngineError::Disabled(spec.id.into(), why));
-3
View File
@@ -79,9 +79,6 @@ impl Session {
}
return Err(EngineError::UnknownCommand(typed.to_string()));
};
if let Some(why) = crate::file_access::commands::refusal(spec.id) {
return Err(EngineError::Disabled(spec.id.into(), why));
}
if transparent && spec.transparent && self.running.is_some() {
// Transparent commands (zoom, pan…) run without cancelling the active one.
if spec.interactive.is_none() {
-5
View File
@@ -291,7 +291,6 @@ pub fn format_angle_list(angles: &[f64]) -> String {
angles.iter().map(|a| format!("{}", (a.to_degrees() * 1e6).round() / 1e6)).collect::<Vec<_>>().join(";")
}
/// Set a system variable, refusing values out of its range and folders the automation roots can't hold.
pub fn set(s: &mut Session, name: &str, v: &Value) -> Result<()> {
let n = name.trim().to_ascii_uppercase();
if is_read_only(&n) {
@@ -388,10 +387,6 @@ pub fn set(s: &mut Session, name: &str, v: &Value) -> Result<()> {
"SAVETIME" => crate::autosave::set_savetime(
as_f64(v).filter(|m| *m >= 0.0 && *m <= f64::from(crate::autosave::MAX_SAVETIME)).ok_or_else(bad)?.round() as u32,
),
// A folder autosave and recovery would use without any further check.
"SAVEFILEPATH" if crate::file_access::current().is_some() => {
return Err(EngineError::Other("SAVEFILEPATH cannot be changed under the automation roots".into()));
}
"SAVEFILEPATH" => crate::autosave::set_savefilepath(v.as_str().ok_or_else(bad)?),
"ISAVEBAK" => crate::autosave::set_isavebak(as_bool(v).ok_or_else(bad)?),
// A number is in degrees; text is an angle typed in AUNITS (SETVAR at the command line).
+4 -141
View File
@@ -3,10 +3,8 @@
//! process-wide, so these tests run one at a time.
use std::sync::Mutex;
use std::time::{Duration, Instant};
use cadcraft_engine::Session;
use cadcraft_engine::cmd::file::MAX_ALIASES;
use cadcraft_engine::cmd::resolve_alias;
use serde_json::json;
@@ -28,10 +26,6 @@ ZZBAD, *NOSUCHCOMMAND
LINE, *CIRCLE
";
fn alias_prefix(count: usize) -> String {
(0..count).map(|i| format!("ZZP{i:05},*LINE\n")).collect()
}
#[test]
fn an_alias_file_adds_and_overrides_aliases() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
@@ -67,148 +61,17 @@ fn an_alias_file_adds_and_overrides_aliases() {
fn reinit_reads_the_alias_file_again() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let dir = TempDir::new("aliases");
let file = dir.file("mine.pgp", "ZZR, *LINE\nzzr, *RECTANG\n");
let file = dir.file("mine.pgp", "ZZR, *RECTANG\n");
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let r = s.execute("aliasedit", &json!({ "file": file })).unwrap();
assert_eq!(r["loaded"], json!(1));
assert_eq!(r["file"], json!(file));
assert_eq!(r["warnings"], json!([]));
s.execute("aliasedit", &json!({ "file": file })).unwrap();
assert_eq!(resolve_alias("zzr"), "rectang");
std::fs::write(&file, "ZZR, *MOVE\nzzr, *CIRCLE\n").unwrap();
std::fs::write(&file, "ZZR, *CIRCLE\n").unwrap();
s.cmdline("reinit").unwrap();
assert_eq!(resolve_alias("zzr"), "circle");
assert!(s.log.iter().any(|l| l.contains("1 command alias")), "{:?}", s.log);
let r = s.execute("aliasedit", &json!({})).unwrap();
assert_eq!(r["file"], json!(file));
assert_eq!(r["aliases"], json!({ "zzr": "circle" }));
let r = s.execute("reinit", &json!({ "text": "ZZS, *LINE\nzzs, *SCALE\n" })).unwrap();
let r = s.execute("reinit", &json!({ "text": "ZZS, *SCALE\n" })).unwrap();
assert_eq!(r["aliases"], json!({ "zzs": "scale" }));
assert_eq!(r["loaded"], json!(1));
assert_eq!(r["warnings"], json!([]));
assert_eq!(r["file"], json!(file), "reloading text keeps the remembered file");
let r = s.execute("reinit", &json!({})).unwrap();
assert_eq!(r["aliases"], json!({ "zzr": "circle" }));
assert_eq!(r["loaded"], json!(1));
assert_eq!(r["file"], json!(file));
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
#[test]
fn valid_redefinitions_win_and_the_listing_stays_sorted() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let text = "ZZZ,*LINE\nZza,*LINE\nzzz,*CIRCLE\nZZA,*NO_SUCH_1933\nLINE,*CIRCLE\n";
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
let aliases = json!({ "zza": "line", "zzz": "circle" });
assert_eq!(r["aliases"], aliases);
assert_eq!(r["loaded"], json!(2), "loaded counts unique aliases, not definitions");
assert_eq!(r["file"], json!(null));
assert_eq!(
r["warnings"],
json!(["line 4: ZZA: unknown command *NO_SUCH_1933; skipped", "line 5: LINE is a command name; it stays the command; skipped"])
);
assert_eq!(resolve_alias("ZZZ"), "circle");
assert_eq!(resolve_alias("zza"), "line", "an invalid redefinition keeps the previous target");
assert_eq!(resolve_alias("line"), "line");
assert_eq!(serde_json::to_string(&r["aliases"]).unwrap(), r#"{"zza":"line","zzz":"circle"}"#);
let listing = s.execute("aliasedit", &json!({})).unwrap();
assert_eq!(listing, json!({ "aliases": aliases, "file": null, "loaded": 0, "warnings": [] }));
let empty = s.execute("aliasedit", &json!({ "text": "" })).unwrap();
assert_eq!(empty, json!({ "aliases": {}, "file": null, "loaded": 0, "warnings": [] }));
assert_eq!(resolve_alias("zza"), "zza", "an empty import replaces the old set");
assert_eq!(resolve_alias("zzz"), "zzz");
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
#[test]
fn duplicates_below_the_limit_leave_room_for_another_alias() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let mut text = alias_prefix(MAX_ALIASES - 1);
for _ in 0..16 {
text.push_str("ZZP00000,*MOVE\nzzp00001,*CIRCLE\n");
}
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
assert_eq!(r["loaded"], json!(MAX_ALIASES - 1));
assert_eq!(r["aliases"].as_object().unwrap().len(), MAX_ALIASES - 1);
assert_eq!(r["warnings"], json!([]));
for i in 0..MAX_ALIASES - 1 {
let expected = match i {
0 => "move",
1 => "circle",
_ => "line",
};
assert_eq!(r["aliases"][format!("zzp{i:05}")], json!(expected));
}
text.push_str("ZZNEW,*PLINE\n");
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
assert_eq!(r["loaded"], json!(MAX_ALIASES));
assert_eq!(r["aliases"].as_object().unwrap().len(), MAX_ALIASES);
assert_eq!(r["aliases"]["zznew"], json!("pline"));
assert_eq!(r["aliases"]["zzp00000"], json!("move"));
assert_eq!(r["aliases"]["zzp00001"], json!("circle"));
assert_eq!(r["warnings"], json!([]), "duplicate definitions do not use up the alias limit");
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
#[test]
fn a_full_file_validates_lines_before_stopping_at_the_next_valid_definition() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let mut text = alias_prefix(MAX_ALIASES);
text.push_str("; comment\nZZP00000,*NO_SUCH_1933\nLINE,*CIRCLE\nZZEXTERNAL, START NOTHING\nmalformed\nZZP00000,*MOVE\nZZAFTER,*CIRCLE\nanother malformed sentinel\n");
let params = json!({ "text": text });
let start = Instant::now();
let result = s.execute("aliasedit", &params);
let elapsed = start.elapsed();
let r = result.unwrap();
assert_eq!(r["loaded"], json!(MAX_ALIASES));
assert_eq!(r["aliases"].as_object().unwrap().len(), MAX_ALIASES);
assert_eq!(r["aliases"]["zzp00000"], json!("line"), "the cap stops even a valid duplicate replacement");
assert!(r["aliases"].get("zzafter").is_none(), "the remainder of the file is skipped");
assert_eq!(
r["warnings"],
json!([
format!("line {}: ZZP00000: unknown command *NO_SUCH_1933; skipped", MAX_ALIASES + 2),
format!("line {}: LINE is a command name; it stays the command; skipped", MAX_ALIASES + 3),
format!("line {}: ZZEXTERNAL is an external command; CADCraft doesn't run programs from alias files", MAX_ALIASES + 4),
format!("line {}: `malformed` is not ALIAS, *COMMAND; skipped", MAX_ALIASES + 5),
format!("line {}: more than {MAX_ALIASES} aliases; the rest are skipped", MAX_ALIASES + 6)
])
);
// Setting one existing alias through JSON has a different rule from importing a full file.
let r = s.execute("aliasedit", &json!({ "set": { "ZZP00000": "move" } })).unwrap();
assert_eq!(r["aliases"]["zzp00000"], json!("move"));
assert_eq!(r["loaded"], json!(1));
assert!(s.execute("aliasedit", &json!({ "set": { "ZZNEW": "line" } })).is_err());
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
// A generous responsiveness guard, not a benchmark or a timeout for a hung import.
assert!(elapsed < Duration::from_secs(5), "importing {MAX_ALIASES} aliases took {elapsed:?}");
}
#[test]
fn the_warning_limit_does_not_stop_a_later_valid_redefinition() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let mut text = String::from("ZZW,*LINE\n");
for _ in 0..101 {
text.push_str("ZZW,*NO_SUCH_1933\n");
}
text.push_str("zzw,*CIRCLE\n");
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
assert_eq!(r["aliases"], json!({ "zzw": "circle" }));
assert_eq!(r["loaded"], json!(1));
let warnings: Vec<_> = (2..=101).map(|no| format!("line {no}: ZZW: unknown command *NO_SUCH_1933; skipped")).collect();
assert_eq!(r["warnings"], json!(warnings), "only the first 100 warnings are returned");
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
+36
View File
@@ -329,3 +329,39 @@ fn auditctl_generates_adt_report_file() {
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_handle_in_the_reserved_band_is_not_repaired_on_every_audit() {
// A file object above HANDLE_LIMIT keeps its handle, and the seed deliberately does not move
// past it (#913). AUDIT must not report that policy as an error its own repair never fixes.
let band = Handle(cadcraft_engine::doc::HANDLE_LIMIT);
let mut d = Drawing::new_imperial();
d.space_mut(&Space::Model).unwrap().push(Entity { handle: band, common: Common::default(), kind: line((0.0, 0.0), (1.0, 0.0)) });
d.handseed = band.0;
for _ in 0..3 {
let r = cadcraft_engine::audit::check(&d);
assert!(r.issues.iter().all(|i| i.kind != "handseed"), "{}", r.message());
}
let mut repaired = d.clone();
let r = cadcraft_engine::audit::repair(&mut repaired);
assert!(r.iter().all(|i| i.kind != "handseed"), "{r:?}");
assert_eq!(repaired.handseed, band.0, "the seed moved past the file's own handle");
}
#[test]
fn an_ordinary_handle_behind_a_reserved_band_one_is_still_repaired() {
// The largest handle is in the reserved band, which the seed deliberately does not follow.
// An ordinary handle above the seed must still be found behind it: it is the one the seed
// has to move past, and skipping the check would leave AUDIT reporting a clean drawing.
let band = Handle(cadcraft_engine::doc::HANDLE_LIMIT);
let mut d = Drawing::new_imperial();
let store = d.space_mut(&Space::Model).unwrap();
store.push(Entity { handle: Handle(20), common: Common::default(), kind: line((0.0, 0.0), (1.0, 0.0)) });
store.push(Entity { handle: band, common: Common::default(), kind: line((2.0, 0.0), (3.0, 0.0)) });
d.handseed = 10;
let r = cadcraft_engine::audit::repair(&mut d);
assert!(r.iter().any(|i| i.kind == "handseed" && i.message.contains("(14)")), "the ordinary handle was hidden: {r:?}");
assert_eq!(d.handseed, 21, "the seed was not moved past the ordinary handle");
let r = cadcraft_engine::audit::repair(&mut d.clone());
assert!(r.iter().all(|i| i.kind != "handseed"), "the repair does not stick: {r:?}");
}
-25
View File
@@ -285,7 +285,6 @@ fn oops_brings_back_what_it_erased_where_it_was() {
assert_eq!(order, [a, b, c]);
}
/// A refused -WBLOCK leaves OOPS as it was.
#[test]
fn a_dash_wblock_refused_during_refedit_leaves_oops_as_it_was() {
let (mut s, a, b, c) = drawing();
@@ -302,27 +301,3 @@ fn a_dash_wblock_refused_during_refedit_leaves_oops_as_it_was() {
s.execute("oops", &json!({})).unwrap();
assert!(alive(&s, c));
}
/// Outside the automation roots the prompt doesn't say whether a file is there.
#[test]
fn the_replace_prompt_says_nothing_about_a_file_outside_the_roots() {
let (mut s, ..) = drawing();
let dir = TempDir::new("dash-wblock-roots");
for d in ["in", "out", "outside"] {
std::fs::create_dir(dir.join(d)).unwrap();
}
let there = dir.join("outside/there.dwg");
std::fs::write(&there, "old").unwrap();
// Without roots the same file gets the prompt, so its absence below is the check's doing.
let (mut free, ..) = drawing();
free.cmdline("-wblock").unwrap();
free.cmdline(&there.display().to_string()).unwrap();
assert!(free.prompt_text().contains("already exists"), "{}", free.prompt_text());
let write = dir.join("out");
let roots = cadcraft_engine::file_access::AutomationRoots::new(Some(&dir.join("in")), Some(&write)).unwrap();
cadcraft_engine::file_access::confine(roots.as_ref(), || {
s.cmdline("-wblock").unwrap();
s.cmdline(&there.display().to_string()).unwrap();
assert!(!s.prompt_text().contains("already exists"), "{}", s.prompt_text());
});
}
+45
View File
@@ -142,6 +142,51 @@ fn bad_input_is_refused_and_changes_nothing() {
assert_eq!(listed(&mut s), json!([]));
}
/// `data` longer than the largest image file encodes to is refused before it is decoded.
#[test]
fn oversized_data_is_refused_before_decoding() {
hooks();
const LIMIT: u64 = 256 << 20;
let mut s = Session::new();
// Not base64 at all: only the check before decoding tells it is too long ("not valid base64"
// otherwise), and nothing is decoded.
let too_long = "!".repeat(usize::try_from(LIMIT.div_ceil(3) * 4 + 1).unwrap());
let e = s.execute("imageattach", &json!({ "path": "a.png", "data": too_long })).unwrap_err().to_string();
assert!(e.contains("`data` is larger than 256 MB"), "{e}");
// Line breaks don't count: base64 wrapped as MIME writes it is taken.
let wrapped: String = base64_encode(&png()).as_bytes().chunks(76).map(|c| format!("{}\r\n", String::from_utf8_lossy(c))).collect();
s.execute("imageattach", &json!({ "path": "wrapped.png", "data": wrapped })).unwrap();
s.execute("undo", &json!({})).unwrap();
// The longest text allowed, holding one byte more than the limit, is refused once decoded.
let groups = usize::try_from(LIMIT / 3).unwrap();
let one_over = format!("{}AAA=", "AAAA".repeat(groups));
assert_eq!(u64::try_from(one_over.len()).unwrap(), LIMIT.div_ceil(3) * 4, "as long as the text for the limit itself");
let e = s.execute("imageattach", &json!({ "path": "a.png", "data": one_over })).unwrap_err().to_string();
assert!(e.contains("`data` is larger than 256 MB"), "{e}");
assert!(images(&s).is_empty());
}
/// A relative path in an unsaved drawing has nothing to be relative to, and the error says so.
#[test]
fn a_relative_path_in_an_unsaved_drawing_says_what_to_do() {
hooks();
let mut s = Session::new();
let e = s.execute("imageattach", &json!({ "path": "missing.png" })).unwrap_err().to_string();
assert!(e.contains("save the drawing first, or give a full path"), "{e}");
let dir = folder("unsaved");
let full = dir.join("missing.png");
let e = s.execute("imageattach", &json!({ "path": full.to_string_lossy() })).unwrap_err().to_string();
assert!(e.contains("file not found") && !e.contains("save the drawing"), "{e}");
// A full Windows path, read as relative elsewhere, is a full path all the same.
for windows in [r"C:\nowhere\a.png", "D:/nowhere/a.png", r"\\server\maps\a.png"] {
let e = s.execute("imageattach", &json!({ "path": windows })).unwrap_err().to_string();
assert!(e.contains("file not found") && !e.contains("save the drawing"), "{windows}: {e}");
}
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn an_image_among_many_objects_keeps_its_pixels() {
// More objects than one build task takes: the display list is built in parts and joined,
+21 -8
View File
@@ -41,8 +41,8 @@ use cadcraft_geom::Vec2;
use craft_shx::Record;
pub use craft_shx::{ShxError, ShxKind, compile};
pub use table::{
FontProvider, OpenGuard, add_drawing_dir, add_drawing_dir_guarded, clear_registered, drawing_dirs, find, font_map, generation, installed,
register, search_path, set_font_dirs, set_font_map, set_provider, set_search_path,
FontProvider, add_drawing_dir, clear_registered, drawing_dirs, find, font_map, generation, installed, register, search_path, set_font_dirs,
set_font_map, set_provider, set_search_path,
};
pub use text::ShxText;
pub(crate) use text::{shape, width};
@@ -56,11 +56,17 @@ pub struct ShxGlyph {
pub advance: Vec2,
}
/// Glyphs cached per font, keyed by (shape, vertical).
type GlyphCache = HashMap<(u16, bool), Option<Arc<ShxGlyph>>>;
/// Glyphs cached per font, keyed by (shape, vertical), and their points in all.
#[derive(Default)]
struct GlyphCache {
glyphs: HashMap<(u16, bool), Option<Arc<ShxGlyph>>>,
points: usize,
}
/// Most glyphs cached per font (a big font has thousands; text uses a few hundred).
const MAX_CACHED_GLYPHS: usize = 16_384;
/// Most points cached per font (16 MB; a glyph may hold thousands of points).
const MAX_CACHED_POINTS: usize = 1 << 20;
/// A parsed SHX file.
pub struct ShxFont {
@@ -203,15 +209,22 @@ impl ShxFont {
}
let vertical = vertical && self.dual;
let key = (number, vertical);
if let Some(g) = self.cache.read().unwrap_or_else(PoisonError::into_inner).get(&key) {
if let Some(g) = self.cache.read().unwrap_or_else(PoisonError::into_inner).glyphs.get(&key) {
return g.clone();
}
let g = program::outline(self, number, vertical).ok().map(Arc::new);
let points = g.as_ref().map_or(0, |g| g.strokes.iter().map(Vec::len).sum::<usize>());
let mut c = self.cache.write().unwrap_or_else(PoisonError::into_inner);
if c.len() >= MAX_CACHED_GLYPHS {
c.clear();
// Another thread may have outlined it in the meantime: its points are counted already.
if let Some(g) = c.glyphs.get(&key) {
return g.clone();
}
c.insert(key, g.clone());
if c.glyphs.len() >= MAX_CACHED_GLYPHS || c.points.saturating_add(points) > MAX_CACHED_POINTS {
c.glyphs.clear();
c.points = 0;
}
c.points = c.points.saturating_add(points);
c.glyphs.insert(key, g.clone());
g
}
}
+19 -108
View File
@@ -20,23 +20,14 @@ use super::{ShxError, ShxFont};
/// app's own font folder). Called with the normalised file name (`romans.shx`); returns the
/// file's bytes. Called without the font table's lock held.
pub trait FontProvider: Send + Sync {
/// The bytes of the font file `file_name`, or `None` when this provider has none by that name.
fn load(&self, file_name: &str) -> Option<Vec<u8>>;
}
/// Decides whether the file at a path may be opened by the font search; asked of every candidate in
/// a folder, before anything opens it.
pub type OpenGuard = Arc<dyn Fn(&Path) -> bool + Send + Sync>;
/// Most fonts kept loaded, and their total bytes.
const MAX_FONTS: usize = 128;
const MAX_LOADED_BYTES: usize = 256 << 20;
/// Most drawing folders and search path entries remembered.
const MAX_DIRS: usize = 32;
/// Most folders whose guards are kept.
const MAX_GUARDED_DIRS: usize = 1024;
/// Most guards kept past [`MAX_GUARDED_DIRS`], each applying to every folder searched.
const MAX_OVERFLOW_GUARDS: usize = 4096;
/// Most font map entries.
const MAX_MAP: usize = 1024;
@@ -47,12 +38,6 @@ struct Table {
loaded_bytes: usize,
provider: Option<Arc<dyn FontProvider>>,
drawing_dirs: Vec<PathBuf>,
/// The guards of the drawing folders that have any, by the owner that gave each one.
drawing_guards: HashMap<PathBuf, Vec<(String, OpenGuard)>>,
/// Guards given once [`MAX_GUARDED_DIRS`] folders had one: they apply to every folder searched.
overflow_guards: Vec<(String, OpenGuard)>,
/// The overflow guards ran out: every file is refused from then on.
overflow_closed: bool,
font_dirs: Vec<PathBuf>,
search_path: Vec<PathBuf>,
map: Vec<(String, String)>,
@@ -133,55 +118,16 @@ pub fn set_provider(provider: Option<Arc<dyn FontProvider>>) {
/// Search the folder of a drawing being opened for the fonts its styles name (most recent
/// first).
pub fn add_drawing_dir(dir: &Path) {
add_dir(dir, None);
}
/// Like [`add_drawing_dir`], with every file the search would open in `dir` put to `guard` first,
/// whatever its name and however it is found in the folder: a font the guard refuses is skipped.
///
/// The table is shared by the whole process, so a folder keeps the guard of every `owner` that gave
/// one (an owner giving it again replaces its own) and a font is opened only when all of them allow
/// it. Adding the folder without a guard never removes one. Fonts found are kept for every caller,
/// so owners with different rules shouldn't share a process.
pub fn add_drawing_dir_guarded(dir: &Path, owner: &str, guard: OpenGuard) {
add_dir(dir, Some((owner, guard)));
}
/// Remember `dir`, most recent first, with the guard it is searched under, if any. The folder's
/// guards are kept after it drops off the list of drawing folders.
fn add_dir(dir: &Path, guard: Option<(&str, OpenGuard)>) {
if dir.as_os_str().is_empty() {
return;
}
let mut t = table();
if guard.is_none() && t.drawing_dirs.first().is_some_and(|d| d == dir) {
if t.drawing_dirs.first().is_some_and(|d| d == dir) {
return;
}
// Guards outlive the drawing list: a folder dropped from it can still be reached as a font
// folder or on the search path. When there is no room for another folder's guards, they apply to
// every folder searched from then on, so nothing is left unguarded.
let no_room = !t.drawing_guards.contains_key(dir) && t.drawing_guards.len() >= MAX_GUARDED_DIRS;
t.drawing_dirs.retain(|d| d != dir);
t.drawing_dirs.insert(0, dir.to_path_buf());
t.drawing_dirs.truncate(MAX_DIRS);
if let Some((owner, guard)) = guard {
if no_room {
// Every overflow guard stays: none may be replaced by another folder's. When even these
// run out, everything is refused from then on.
let kept = &mut t.overflow_guards;
if !kept.iter().any(|(_, g)| Arc::ptr_eq(g, &guard)) {
if kept.len() < MAX_OVERFLOW_GUARDS {
kept.push((owner.to_string(), guard));
} else {
t.overflow_closed = true;
}
}
} else {
let guards = t.drawing_guards.entry(dir.to_path_buf()).or_default();
guards.retain(|(o, _)| o != owner);
guards.push((owner.to_string(), guard));
}
}
t.changed();
}
@@ -248,7 +194,7 @@ pub fn generation() -> u64 {
/// The SHX font file a style or linetype names, if CADCraft can find and read it.
pub fn find(name: &str) -> Option<Arc<ShxFont>> {
let mut k = key(name)?;
let (provider, folders, (guarded, overflow), generation) = {
let (provider, dirs, generation) = {
let t = table();
// The font map renames once (a map can't loop).
if let Some(to) = t.map.iter().find(|(from, _)| *from == k).and_then(|(_, to)| key(to)) {
@@ -260,29 +206,9 @@ pub fn find(name: &str) -> Option<Arc<ShxFont>> {
if let Some(r) = t.resolved.get(&k) {
return r.clone();
}
let folders: Vec<PathBuf> = t.drawing_dirs.iter().chain(t.font_dirs.iter()).chain(t.search_path.iter()).cloned().collect();
let guarded: Vec<(PathBuf, Vec<OpenGuard>)> =
t.drawing_guards.iter().map(|(d, g)| (d.clone(), g.iter().map(|(_, g)| g.clone()).collect())).collect();
let mut overflow: Vec<OpenGuard> = t.overflow_guards.iter().map(|(_, g)| g.clone()).collect();
if t.overflow_closed {
overflow.push(Arc::new(|_: &Path| false));
}
(t.provider.clone(), folders, (guarded, overflow), t.generation)
let dirs: Vec<PathBuf> = t.drawing_dirs.iter().chain(t.font_dirs.iter()).chain(t.search_path.iter()).cloned().collect();
(t.provider.clone(), dirs, t.generation)
};
// A guard belongs to the folder, however the search reaches it: a font folder or the search path
// naming the same folder as a drawing's is held to the same guards.
// Each folder is resolved once per lookup (spelled, and as the file system has it).
let resolved = |d: &Path| std::fs::canonicalize(d).ok();
let guarded: Vec<(PathBuf, Option<PathBuf>, Vec<OpenGuard>)> = guarded.into_iter().map(|(d, g)| (d.clone(), resolved(&d), g)).collect();
let dirs: Vec<(PathBuf, Vec<OpenGuard>)> = folders
.into_iter()
.map(|d| {
let real = resolved(&d);
let own = guarded.iter().filter(|(g, r, _)| *g == d || (real.is_some() && *r == real)).flat_map(|(_, _, g)| g.iter().cloned());
let guards = own.chain(overflow.iter().cloned()).collect();
(d, guards)
})
.collect();
let font = provider
.and_then(|p| p.load(&k))
.or_else(|| read_from(&dirs, &k))
@@ -340,24 +266,24 @@ pub fn installed() -> Vec<String> {
/// The file `name` (a lower-case key) in the first of `dirs` that has it, whatever the case of
/// its name: lower-case, upper-case, else any other case found in the directory (`Simplex.shx`
/// on a case-sensitive file system). Each of a folder's guards is asked about each candidate before
/// anything opens it, so a link is judged by where it leads.
/// on a case-sensitive file system).
#[cfg(not(target_arch = "wasm32"))]
fn read_from(dirs: &[(PathBuf, Vec<OpenGuard>)], name: &str) -> Option<Vec<u8>> {
for (d, guards) in dirs {
let read = |file: &Path| -> Option<Vec<u8>> {
if !guards.iter().all(|g| g(file)) {
return None;
}
read_file(file)
};
fn read_from(dirs: &[PathBuf], name: &str) -> Option<Vec<u8>> {
use std::io::Read as _;
let read = |file: &Path| -> Option<Vec<u8>> {
let meta = std::fs::metadata(file).ok()?;
if !meta.is_file() || meta.len() > MAX_FILE_BYTES as u64 {
return None;
}
let mut bytes = Vec::new();
let limit = u64::try_from(MAX_FILE_BYTES).unwrap_or(u64::MAX).saturating_add(1);
std::fs::File::open(file).and_then(|f| f.take(limit).read_to_end(&mut bytes)).ok()?;
Some(bytes)
};
for d in dirs {
if let Some(b) = [d.join(name), d.join(name.to_ascii_uppercase())].iter().find_map(|f| read(f)) {
return Some(b);
}
// The folder is listed only when its guards allow the folder itself.
if !guards.iter().all(|g| g(d)) {
continue;
}
let Ok(entries) = std::fs::read_dir(d) else { continue };
let found = entries
.take(MAX_DIR_ENTRIES)
@@ -371,22 +297,7 @@ fn read_from(dirs: &[(PathBuf, Vec<OpenGuard>)], name: &str) -> Option<Vec<u8>>
None
}
/// The bytes of the SHX file at `file`, when it is a file of a sensible size.
#[cfg(not(target_arch = "wasm32"))]
fn read_file(file: &Path) -> Option<Vec<u8>> {
use std::io::Read as _;
let meta = std::fs::metadata(file).ok()?;
if !meta.is_file() || meta.len() > MAX_FILE_BYTES as u64 {
return None;
}
let mut bytes = Vec::new();
let limit = u64::try_from(MAX_FILE_BYTES).unwrap_or(u64::MAX).saturating_add(1);
std::fs::File::open(file).and_then(|f| f.take(limit).read_to_end(&mut bytes)).ok()?;
Some(bytes)
}
/// On the web there are no folders to search.
#[cfg(target_arch = "wasm32")]
fn read_from(_dirs: &[(PathBuf, Vec<OpenGuard>)], _name: &str) -> Option<Vec<u8>> {
fn read_from(_dirs: &[PathBuf], _name: &str) -> Option<Vec<u8>> {
None
}
+16
View File
@@ -309,6 +309,22 @@ fn hostile_files_never_panic() {
assert!(compile("").is_err());
}
#[test]
fn the_glyph_cache_is_bounded_by_points() {
// Hostile: every glyph at the point bound, so 16,384 cached glyphs would hold 2 GB.
let mut src = format!("*2,1,HUNDRED\n{}0\n*3,3,V\n011,019,0\n", "7,3,".repeat(100));
for n in 10..=200 {
src.push_str(&format!("*{n},1,HEAVY\n{}0\n", "7,2,".repeat(40)));
}
let f = font(&src);
for n in 10..=200 {
assert!(f.glyph(n, false).is_some());
}
let c = f.cache.read().unwrap();
let cached: usize = c.glyphs.values().flatten().map(|g| g.strokes.iter().map(Vec::len).sum::<usize>()).sum();
assert!(cached <= MAX_CACHED_POINTS && cached == c.points, "{cached}");
}
/// Register a compiled test font under `name` (each test its own names: the table is shared).
fn reg(name: &str, src: &str) {
register(name, &compile(src).unwrap()).unwrap();
-100
View File
@@ -1,100 +0,0 @@
//! A guarded drawing folder: the font search asks the guard about every file it would open there,
//! before opening it (the automation roots use this to keep a font link from leading out of them).
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use cadcraft_fonts::shx;
const FONT: &str = "*0,4,guard\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n";
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(std::path::PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder for `tag`: creating it must not find one already there.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// The lower-case file name of `file`, so a guard never reads the test folder's own name.
fn name(file: &Path) -> String {
file.file_name().map(|n| n.to_string_lossy().to_ascii_lowercase()).unwrap_or_default()
}
/// Every candidate the search opens in a guarded folder goes to the guard first, whatever its name
/// or how the search finds it, and a font the guard refuses is skipped while the others are used.
#[test]
fn every_file_the_search_opens_goes_to_the_guard_first() {
let bytes = shx::compile(FONT).unwrap();
let owner = fresh_dir("guard");
let dir = owner.0.clone();
std::fs::write(dir.join("cadcraft-guard-ok.shx"), &bytes).unwrap();
std::fs::write(dir.join("cadcraft-guard-bad.shx"), &bytes).unwrap();
// Found only by looking through the folder, as a link under another spelling would be.
std::fs::write(dir.join("CadCraft-Guard-Mixed.SHX"), &bytes).unwrap();
std::fs::write(dir.join("CadCraft-Guard-Badmixed.SHX"), &bytes).unwrap();
let asked: Arc<Mutex<Vec<PathBuf>>> = Arc::default();
let log = asked.clone();
shx::add_drawing_dir_guarded(
&dir,
"first",
Arc::new(move |file: &Path| {
log.lock().unwrap().push(file.to_path_buf());
!name(file).contains("bad")
}),
);
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
assert!(shx::find("cadcraft-guard-mixed.shx").is_some(), "a name found by looking through the folder");
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "a font the guard refuses is skipped");
assert!(shx::find("cadcraft-guard-badmixed.shx").is_none(), "also one found by looking through the folder");
let asked = asked.lock().unwrap();
// The guard saw each font's file under the spelling the search tried (a file system that
// ignores case answers the first one, so only the letters are compared).
for file in ["cadcraft-guard-ok.shx", "cadcraft-guard-bad.shx", "cadcraft-guard-mixed.shx", "cadcraft-guard-badmixed.shx"] {
let want = dir.join(file).to_string_lossy().to_ascii_lowercase();
assert!(asked.iter().any(|a| a.to_string_lossy().to_ascii_lowercase() == want), "the guard was asked about {file}: {asked:?}");
}
drop(asked);
// The folder added again without a guard (another session in the process) keeps its guard.
shx::add_drawing_dir(&dir);
assert!(shx::find("cadcraft-guard-bad.shx").is_none());
// Another owner's guard is required as well: a font is opened only when every owner allows it.
shx::add_drawing_dir_guarded(&dir, "second", Arc::new(|file: &Path| !name(file).contains("ok")));
assert!(shx::find("cadcraft-guard-ok.shx").is_none(), "refused by the second owner");
assert!(shx::find("cadcraft-guard-mixed.shx").is_some(), "allowed by both");
// An owner giving its guard again replaces its own, and the other's stays.
shx::add_drawing_dir_guarded(&dir, "second", Arc::new(|_: &Path| true));
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "the first owner's guard still holds");
// The same folder named as a font folder or on the search path is held to its guards too.
shx::set_font_dirs(vec![dir.clone()]);
shx::set_search_path(&dir.to_string_lossy());
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "a font folder or the search path doesn't lift the guard");
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
// The folder falling off the list of drawing folders (the list is short) keeps its guards while a
// font folder or the search path still reaches it.
for n in 0..40 {
shx::add_drawing_dir(&dir.join(format!("other-{n}")));
}
assert!(!shx::drawing_dirs().contains(&dir));
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "the outside font stays rejected after the eviction");
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
}
-50
View File
@@ -1,50 +0,0 @@
//! When even the overflow guards run out, every font is refused, whatever name the owners gave.
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::Path;
use std::sync::Arc;
use cadcraft_fonts::shx;
const FONT: &str = "*0,4,closed\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n";
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(std::path::PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder for `tag`: creating it must not find one already there.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// Past every limit, a font that no guard objects to is still refused, also when an owner is called
/// `closed`.
#[test]
fn guards_that_ran_out_refuse_every_font() {
let bytes = shx::compile(FONT).unwrap();
let owner = fresh_dir("closed");
let dir = owner.0.clone();
std::fs::write(dir.join("cadcraft-closed-ok.shx"), &bytes).unwrap();
shx::set_font_dirs(vec![dir.clone()]);
assert!(shx::find("cadcraft-closed-ok.shx").is_some(), "found while nothing guards the folder");
for n in 0..6000 {
shx::add_drawing_dir_guarded(&dir.join(format!("drawings-{n}")), "closed", Arc::new(|_: &Path| true));
}
assert!(shx::find("cadcraft-closed-ok.shx").is_none(), "refused once the guards ran out");
}
-55
View File
@@ -1,55 +0,0 @@
//! A guarded folder is listed only when its guards allow the folder itself, so a folder outside the
//! automation roots isn't read even for the names in it.
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use cadcraft_fonts::shx;
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder: creating it must not find one already there.
fn fresh_dir() -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-listing-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// Looking for a font that isn't there makes the search list the folder, and the guard is asked
/// about the folder itself first; a guard that refuses it ends the search there.
#[test]
fn the_folder_itself_goes_to_the_guard_before_it_is_listed() {
let owner = fresh_dir();
let dir = owner.0.clone();
let asked: Arc<Mutex<Vec<PathBuf>>> = Arc::default();
let log = asked.clone();
let folder = dir.clone();
shx::add_drawing_dir_guarded(
&dir,
"listing",
Arc::new(move |path: &Path| {
log.lock().unwrap().push(path.to_path_buf());
path != folder
}),
);
assert!(shx::find("cadcraft-listing-missing.shx").is_none());
let seen = asked.lock().unwrap().clone();
assert!(seen.contains(&dir), "the guard was asked about the folder: {seen:?}");
}
-59
View File
@@ -1,59 +0,0 @@
//! Past the number of guarded folders kept, a new folder's guards apply to every folder searched, so
//! no font folder or search path entry is left unguarded.
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::Path;
use std::sync::Arc;
use cadcraft_fonts::shx;
const FONT: &str = "*0,4,overflow\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n";
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(std::path::PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder for `tag`: creating it must not find one already there.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// With far more guarded folders than are kept, a font folder holding a font the guards refuse still
/// has it refused, and one the guards allow is still found.
#[test]
fn guards_past_the_limit_apply_to_every_folder() {
let bytes = shx::compile(FONT).unwrap();
let owner = fresh_dir("overflow");
let dir = owner.0.clone();
std::fs::write(dir.join("cadcraft-overflow-bad.shx"), &bytes).unwrap();
std::fs::write(dir.join("cadcraft-overflow-ok.shx"), &bytes).unwrap();
for n in 0..1100 {
let folder = dir.join(format!("drawings-{n}"));
shx::add_drawing_dir_guarded(
&folder,
"session",
Arc::new(|file: &Path| !file.file_name().is_some_and(|n| n.to_string_lossy().contains("bad"))),
);
}
// A later folder with the same owner and a guard that allows everything doesn't lift the others.
shx::add_drawing_dir_guarded(&dir.join("last-drawings"), "session", Arc::new(|_: &Path| true));
shx::set_font_dirs(vec![dir.clone()]);
assert!(shx::find("cadcraft-overflow-bad.shx").is_none(), "refused by a guard given past the limit");
assert!(shx::find("cadcraft-overflow-ok.shx").is_some());
}
+4 -4
View File
@@ -9,7 +9,7 @@ use std::sync::Arc;
use cadcraft_doc::{Drawing, EntityKind, EntityStore, Handle, Image};
use cadcraft_geom::{Vec2, Vec3};
use craft_dxf::{SectionRef, Tag};
use craft_dxf::{Section, Tag};
/// Most clip boundary vertices kept per image (hostile files).
const MAX_CLIP: usize = 100_000;
@@ -79,14 +79,14 @@ fn has_images(store: &EntityStore) -> bool {
}
/// Fill in each image's definition (path, name, pixel size) from the IMAGEDEF it points to.
pub(crate) fn resolve(secs: &[SectionRef<'_>], d: &mut Drawing) {
pub(crate) fn resolve(secs: &[Section], d: &mut Drawing) {
if !has_images(&d.model) && !d.layouts.iter().any(|l| has_images(&l.entities)) && !d.blocks.values().any(|b| has_images(&b.entities)) {
return;
}
// IMAGE handle → IMAGEDEF handle.
let mut refs: HashMap<Handle, String> = HashMap::new();
for s in secs.iter().filter(|s| s.name == "ENTITIES" || s.name == "BLOCKS") {
each_record(s.tags, |kind, tags| {
each_record(&s.tags, |kind, tags| {
if kind != "IMAGE" {
return;
}
@@ -101,7 +101,7 @@ pub(crate) fn resolve(secs: &[SectionRef<'_>], d: &mut Drawing) {
let mut defs: HashMap<String, Def> = HashMap::new();
let mut names: HashMap<String, String> = HashMap::new();
for s in secs.iter().filter(|s| s.name == "OBJECTS") {
each_record(s.tags, |kind, tags| match kind {
each_record(&s.tags, |kind, tags| match kind {
"IMAGEDEF" => {
let Some(h) = tags.iter().find(|t| t.code == 5).map(|t| key(&t.str())) else { return };
let start = tags.iter().position(|t| t.code == 100 && t.str() == "AcDbRasterImageDef").unwrap_or(0);
+3 -3
View File
@@ -13,7 +13,7 @@ use cadcraft_doc::{
MLineJust, MLineStyle, MLineVertex, STANDARD_MLINE_STYLE,
};
use cadcraft_geom::{Vec2, Vec3};
use craft_dxf::{SectionRef, Tag};
use craft_dxf::{Section, Tag};
/// Most groups 41 kept per element and vertex (start, then break pairs).
const MAX_PARAMS: usize = 2 * MAX_MLINE_CUTS + 2;
@@ -333,10 +333,10 @@ fn has_mlines(store: &EntityStore) -> bool {
}
/// Read the multiline styles, then give every multiline its style's elements, caps and fill.
pub(crate) fn resolve(secs: &[SectionRef<'_>], d: &mut Drawing) {
pub(crate) fn resolve(secs: &[Section], d: &mut Drawing) {
let mut styles: Vec<MLineStyle> = Vec::new();
for s in secs.iter().filter(|s| s.name == "OBJECTS") {
each_record(s.tags, |kind, tags| {
each_record(&s.tags, |kind, tags| {
if kind == "MLINESTYLE"
&& styles.len() < MAX_STYLES
&& let Some(st) = read_style(tags)
+38 -10
View File
@@ -18,7 +18,7 @@ use std::sync::Arc;
use cadcraft_doc::foreign::{Foreign, ForeignExtra, ForeignKey, ForeignObject, class_group, class_index, class_number};
use cadcraft_doc::{Drawing, Entity, EntityKind, Handle, RawTag, Unknown};
use craft_dxf::{SectionRef, Tag};
use craft_dxf::{Section, Tag};
/// Named object dictionary entries CADCraft writes itself from its model (plus every key that
/// starts with `CADCRAFT`): they are read into the model, not kept raw. A change that starts
@@ -322,8 +322,8 @@ fn put_xdata(d: &mut Drawing, mut xdata: HashMap<Handle, Vec<RawTag>>) {
}
/// Keep what `secs` holds that the reader did not model in `d.foreign`.
pub(crate) fn read(secs: &[SectionRef<'_>], d: &mut Drawing) {
let get = |name: &str| secs.iter().find(|s| s.name == name).map(|s| split(s.tags)).unwrap_or_default();
pub(crate) fn read(secs: &[Section], d: &mut Drawing) {
let get = |name: &str| secs.iter().find(|s| s.name == name).map(|s| split(&s.tags)).unwrap_or_default();
let (classes, tables, blocks, entities, objects) = (get("CLASSES"), get("TABLES"), get("BLOCKS"), get("ENTITIES"), get("OBJECTS"));
// The drawing's entities by handle: whether each is of a type CADCraft doesn't model.
let ents = entity_types(d);
@@ -465,7 +465,7 @@ pub(crate) fn read(secs: &[SectionRef<'_>], d: &mut Drawing) {
/// The `$ACADVER` the file's own HEADER section declares, if it does. Not the drawing's: a new
/// drawing starts as AC1032, and a file without the variable would leave that default there.
fn file_version(secs: &[SectionRef<'_>]) -> Option<String> {
fn file_version(secs: &[Section]) -> Option<String> {
let header = secs.iter().find(|s| s.name.eq_ignore_ascii_case("HEADER"))?;
let at = header.tags.iter().position(|t| t.code == 9 && t.str().trim().eq_ignore_ascii_case("$ACADVER"))?;
let value = header.tags.get(at + 1).filter(|t| t.code != 9)?.str();
@@ -1062,11 +1062,10 @@ pub(crate) fn finish(tags: &mut Vec<Tag>, d: &Drawing, reactors: &HashMap<Handle
alive_memo
});
// New handles for the written kept objects, above every written handle and the seed.
let mut next = seed(tags).max(max_handle(tags).saturating_add(1));
let mut fresh = Fresh::new(tags);
let mut alive: HashMap<String, String> = HashMap::new();
for o in f.objects.iter().filter(|o| alive_memo.get(&o.handle.hex()) == Some(&true)) {
alive.insert(o.handle.hex(), format!("{next:X}"));
next = next.saturating_add(1);
alive.insert(o.handle.hex(), format!("{:X}", fresh.take()));
}
let entities: HashSet<String> = all_entities(d).map(|e| e.handle.hex()).filter(|h| written.contains(h)).collect();
let map = Map { f, alive, raw: objs.keys().cloned().collect(), roles, entities };
@@ -1389,19 +1388,18 @@ fn add_appids(out: &mut Vec<Tag>) {
return;
}
// New handles above the seed, which is then moved past them.
let mut next = seed(out).max(max_handle(out).saturating_add(1));
let mut fresh = Fresh::new(out);
let mut add = Vec::new();
for app in &missing {
add.extend([
Tag::s(0, "APPID"),
Tag::s(5, format!("{next:X}")),
Tag::s(5, format!("{:X}", fresh.take())),
Tag::s(330, table_h.clone()),
Tag::s(100, "AcDbSymbolTableRecord"),
Tag::s(100, "AcDbRegAppTableRecord"),
Tag::s(2, (*app).clone()),
Tag::i(70, 0),
]);
next = next.saturating_add(1);
}
let end_at = end.start;
if let Some(count) = out.get_mut(t.start + 1..t.end).and_then(|b| b.iter_mut().find(|x| x.code == 70)) {
@@ -1420,6 +1418,36 @@ fn seed(tags: &[Tag]) -> u64 {
seed_index(tags).and_then(|i| tags.get(i)).and_then(|t| Handle::parse_hex(&t.str())).map_or(0, |h| h.0)
}
/// New handles for records added to written tags: above the seed and every handle written, and
/// never one a record already holds. A file may hold the top handle (#913): then counting on from
/// it would give every added record that same handle, so past the top of the range the numbering
/// goes on in the reserved band above [`cadcraft_doc::HANDLE_LIMIT`], skipping the handles there.
struct Fresh {
next: u64,
used: HashSet<u64>,
}
impl Fresh {
fn new(tags: &[Tag]) -> Self {
let used: HashSet<u64> =
tags.iter().filter(|t| t.code == 5 || t.code == 105).filter_map(|t| Handle::parse_hex(&t.str())).map(|h| h.0).collect();
let above = used.iter().max().map_or(0, |h| h.checked_add(1).unwrap_or(cadcraft_doc::HANDLE_LIMIT));
Fresh { next: seed(tags).max(above), used }
}
/// The next free handle. Each handle skipped is one a record holds, so the walk is bounded
/// by their count (and handle 0, which means "none").
fn take(&mut self) -> u64 {
for _ in 0..self.used.len().saturating_add(2) {
let h = self.next;
self.next = h.checked_add(1).unwrap_or(cadcraft_doc::HANDLE_LIMIT);
if h != 0 && self.used.insert(h) {
return h;
}
}
self.next
}
}
/// The largest handle of a record (groups 5 and 105).
fn max_handle(tags: &[Tag]) -> u64 {
tags.iter().filter(|t| t.code == 5 || t.code == 105).filter_map(|t| Handle::parse_hex(&t.str())).map(|h| h.0).max().unwrap_or(0)
+40 -12
View File
@@ -10,7 +10,7 @@ use cadcraft_doc::{
RayLine, Solid, Table, TableCell, Text, TextStyle, Tolerance, Transparency, Ucs, Unknown, VAlign, Viewport, VportConfig, VportTile, Wipeout,
};
use cadcraft_geom::{PolyVertex, Spline, Vec2, Vec3};
use craft_dxf::{Tag, record_slices, section_slices};
use craft_dxf::{Tag, records, sections};
use crate::{IoError, Result};
@@ -85,7 +85,7 @@ type LayoutDef = (String, u32, String, PageSetup, Option<(Vec2, Vec2)>);
/// Import DXF sections while sharing one materialized-table-cell budget across blocks and entity sections.
fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
let tags = craft_dxf::parse(bytes).map_err(|e| IoError::Format(e.to_string()))?;
let secs = section_slices(&tags);
let secs = sections(&tags);
if secs.is_empty() {
return Err(IoError::Format("no sections found".into()));
}
@@ -102,27 +102,52 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
// its $HANDSEED can be lower than its handles, and entities made while reading (the faces of
// a polygon mesh) would otherwise get handles that records further on still have. A file
// CADCraft wrote names its own next handle, above which its rebuilt records are numbered
// (#495), so it is left to that.
// (#495), so for it only the entity records are reserved. Handles in the reserved band are
// reserved for allocation rather than followed (#913): a handle-less entity read before the
// section that names one is placed would otherwise be given it and replace the record (#1276).
let ours = secs.iter().any(|s| s.name == "OBJECTS" && s.tags.iter().any(|t| t.code == 3 && t.str() == crate::dxf_ext::HANDSEED_KEY));
for t in secs.iter().filter(|_| !ours).flat_map(|s| s.tags.iter()).filter(|t| t.code == 5 || t.code == 105) {
if let Some(h) = Handle::parse_hex(t.str().trim()) {
d.bump_handseed(h);
if ours {
// Its table and object records are numbered above its seed and rebuilt on save (#495),
// so only its entities are reserved. Reading is section by section: an entity that has
// no handle, or repeats one within its section, gets a fresh handle, and that must not
// be one an entity of a later section still names. `BLOCK` and `ENDBLK` are structural
// records, not entities, and are left out so they don't move the saved seed.
for (kind, tags) in secs.iter().filter(|s| s.name == "BLOCKS" || s.name == "ENTITIES").flat_map(|s| records(&s.tags)) {
if matches!(kind.as_str(), "BLOCK" | "ENDBLK") {
continue;
}
if let Some(h) = tags.iter().find(|t| t.code == 5).and_then(|t| Handle::parse_hex(t.str().trim())) {
d.bump_handseed(h);
d.reserve_handle(h);
}
}
} else {
for s in &secs {
let entity_section = s.name == "BLOCKS" || s.name == "ENTITIES";
for t in s.tags.iter().filter(|t| t.code == 5 || t.code == 105) {
if let Some(h) = Handle::parse_hex(t.str().trim()) {
d.bump_handseed(h);
if entity_section {
d.reserve_handle(h);
}
}
}
}
}
let mut skipped = std::collections::BTreeMap::new();
count_skipped(&mut skipped, "(no section)", outside_sections(&tags));
for s in &secs {
match s.name {
"HEADER" => header(s.tags, &mut d),
"TABLES" => tables(s.tags, &mut d, &mut rx),
"BLOCKS" => blocks.extend(read_blocks(s.tags, &mut d, &mut rx, &mut table_cells_left, &mut skipped)),
match s.name.as_str() {
"HEADER" => header(&s.tags, &mut d),
"TABLES" => tables(&s.tags, &mut d, &mut rx),
"BLOCKS" => blocks.extend(read_blocks(&s.tags, &mut d, &mut rx, &mut table_cells_left, &mut skipped)),
// A damaged file may split its entities over several ENTITIES sections (#865).
"ENTITIES" => {
let mut n = 0;
entities.extend(parse_entities(&record_slices(s.tags), &mut d, &mut rx, &mut n, &mut table_cells_left));
entities.extend(parse_entities(&records(&s.tags), &mut d, &mut rx, &mut n, &mut table_cells_left));
count_skipped(&mut skipped, "ENTITIES", n);
}
"OBJECTS" => read_objects(s.tags, &mut objs, &mut layout_objs),
"OBJECTS" => read_objects(&s.tags, &mut objs, &mut layout_objs),
_ => {}
}
}
@@ -148,6 +173,9 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
crate::dxf_raw::read(&secs, &mut d);
crate::dxf_clip::read(&mut d);
d.skipped_records = skipped;
// Every record is placed now, and an object holding a reserved handle keeps it from new
// objects by itself. Kept, the set would be copied with every undo step of the drawing.
d.reserved_handles.clear();
Ok(d)
}
+6 -5
View File
@@ -1,10 +1,10 @@
use super::common::T;
use super::entities::{entity_extras, entity_plot_style, entity_with_table_budget, insert_attribs, polyline_entity};
use super::objects::{MAX_OBJECTS, Objects, page_setup};
use super::{Block, BlockDef, Drawing, Entity, EntityKind, Handle, HashMap, Layout, LayoutDef, Rx, Tag, Vec2, record_slices};
use super::{Block, BlockDef, Drawing, Entity, EntityKind, Handle, HashMap, Layout, LayoutDef, Rx, Tag, Vec2, records};
pub(super) fn parse_entities(
recs: &[(String, &[Tag])],
recs: &[(String, Vec<Tag>)],
d: &mut Drawing,
rx: &mut Rx,
skipped: &mut usize,
@@ -55,6 +55,7 @@ pub(super) fn parse_entities(
}
if let Some((c, mut k)) = kindent {
let h = match handle {
// A file's handles keep their identity, however high they are (#913, #939).
Some(h) => {
d.bump_handseed(h);
h
@@ -91,7 +92,7 @@ pub(super) fn read_blocks(
table_cells_left: &mut usize,
skipped: &mut std::collections::BTreeMap<String, usize>,
) -> Vec<BlockDef> {
let recs = record_slices(tags);
let recs = records(tags);
for (k, tg) in &recs {
let t = T(tg);
if k == "BLOCK" && t.i(70).unwrap_or(0) & 4 != 0 {
@@ -133,8 +134,8 @@ pub(super) fn read_blocks(
/// Read the OBJECTS section into `objs`, and each LAYOUT into `layout_objs`.
pub(super) fn read_objects(tags: &[Tag], objs: &mut Objects, layout_objs: &mut Vec<LayoutDef>) {
for (k, tg) in record_slices(tags) {
objs.add(&k, tg);
for (k, tg) in records(tags) {
objs.add(&k, &tg);
if k == "LAYOUT" {
// Fields after the AcDbLayout marker (AcDbPlotSettings also has a code 1).
let start = tg.iter().position(|x| x.code == 100 && x.str() == "AcDbLayout").unwrap_or(0);
+5 -5
View File
@@ -5,7 +5,7 @@ use super::text::{attdef, attrib_modes, attrib_props, mtext_from, multiline_attr
use super::{
Arc, Attrib, Circle, Common, DimKind, Dimension, Ellipse, EntityKind, Face3d, Handle, HashMap, Helix, HelixConstrain, Insert, Leader, Line,
LwPolyline, MAX_FRAME_CHARS, Point, PolyVertex, Polyline3d, RawTag, RayLine, Rx, Solid, Spline, Table, TableCell, Tag, Tolerance, Unknown, Vec2,
Vec3, Viewport, Wipeout, record_slices,
Vec3, Viewport, Wipeout, records,
};
use cadcraft_doc::PolyfaceMesh;
@@ -420,10 +420,10 @@ pub(super) fn acad_table(tags: &[Tag], table_cells_left: &mut usize) -> Table {
/// The plot style names of a file: the entries of the `ACAD_PLOTSTYLENAME` dictionary of the
/// named object dictionary (the first object), by placeholder handle.
pub(super) fn plot_style_names(secs: &[craft_dxf::SectionRef<'_>]) -> HashMap<String, String> {
pub(super) fn plot_style_names(secs: &[craft_dxf::Section]) -> HashMap<String, String> {
let mut out = HashMap::new();
let Some(objects) = secs.iter().find(|s| s.name == "OBJECTS") else { return out };
let recs = record_slices(objects.tags);
let recs = records(&objects.tags);
let entries = |tags: &[Tag]| {
let mut v: Vec<(String, String)> = Vec::new();
let mut name: Option<String> = None;
@@ -543,7 +543,7 @@ pub(super) fn entity_extras(kind: &str, tags: &[Tag], h: Handle, k: &mut EntityK
/// can't be placed are counted in `skipped`.
/// The entity of a POLYLINE, with its mesh faces (advancing `i` past its VERTEX records). `None`
/// for a mesh without faces.
pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) -> Option<(Common, EntityKind, Vec<EntityKind>)> {
pub(super) fn polyline_entity(recs: &[(String, Vec<Tag>)], i: &mut usize, t: &T) -> Option<(Common, EntityKind, Vec<EntityKind>)> {
let flags = t.i(70).unwrap_or(0);
let mut pts: Vec<(Vec3, f64, f64, f64)> = Vec::new();
// Polyface face records (VERTEX 70 bit 128 without 64): vertex indices 71–74.
@@ -601,7 +601,7 @@ pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) -
}
/// The ATTRIB records after an INSERT, advancing `i` past them and their SEQEND.
pub(super) fn insert_attribs(recs: &[(String, &[Tag])], i: &mut usize, ins_layer: &str) -> Vec<Attrib> {
pub(super) fn insert_attribs(recs: &[(String, Vec<Tag>)], i: &mut usize, ins_layer: &str) -> Vec<Attrib> {
let mut attribs = Vec::new();
while let Some((k2, t2)) = recs.get(*i) {
if k2 == "ATTRIB" {
+12 -12
View File
@@ -2,7 +2,7 @@ use super::common::T;
use super::objects::MAX_OBJECTS;
use super::{
Color, DashElement, DimStyle, Drawing, HVal, HashMap, Layer, Linetype, Lineweight, NamedView, Rgb, Rx, Tag, TextStyle, Ucs, Vec2, Vec3,
VportConfig, VportTile, record_slices,
VportConfig, VportTile, records,
};
use cadcraft_fonts::windows::windows_font;
@@ -92,7 +92,7 @@ fn style_font(tags: &[Tag], file: String) -> String {
/// Load symbol tables and resolve handle references, indexing layer names for case-insensitive updates.
pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
let recs = record_slices(tags);
let recs = records(tags);
// STYLE handle → name, or the shape file of an unnamed shape style (linetype elements).
let ltype_styles: HashMap<String, String> = recs
.iter()
@@ -114,7 +114,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
let mut linetype_names: std::collections::HashSet<String> = d.linetypes.iter().map(|l| l.name.to_ascii_lowercase()).collect();
let mut style_index: HashMap<String, usize> = d.text_styles.iter().enumerate().map(|(i, s)| (s.name.to_ascii_lowercase(), i)).collect();
for (kind, tg) in recs {
let t = T(tg);
let t = T(&tg);
match kind.as_str() {
"LAYER" => {
let name = t.s(2).unwrap_or_default();
@@ -141,11 +141,11 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
if let Some(n) = t.s(390).and_then(|h| rx.pstyles.get(&h.trim().to_ascii_uppercase())) {
l.plot_style = n.clone();
}
let alpha = crate::dxf_ext::xdata(tg, crate::dxf_ext::LAYER_TRANSPARENCY_APP).iter().find(|x| x.code == 1071);
let alpha = crate::dxf_ext::xdata(&tg, crate::dxf_ext::LAYER_TRANSPARENCY_APP).iter().find(|x| x.code == 1071);
if let Some(pct) = alpha.and_then(|x| crate::dxf_ext::transparency_from_dxf(x.i64())) {
l.transparency = pct;
}
if let Some(desc) = crate::dxf_ext::xdata(tg, crate::dxf_ext::LAYER_DESCRIPTION_APP).iter().filter(|x| x.code == 1000).nth(1) {
if let Some(desc) = crate::dxf_ext::xdata(&tg, crate::dxf_ext::LAYER_DESCRIPTION_APP).iter().filter(|x| x.code == 1000).nth(1) {
l.description = desc.str();
}
match layer_index.get(&name.to_ascii_lowercase()) {
@@ -166,7 +166,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
continue;
}
linetype_names.insert(name.to_ascii_lowercase());
let pattern = ltype_pattern(tg, &ltype_styles);
let pattern = ltype_pattern(&tg, &ltype_styles);
d.linetypes.push(Linetype { name, description: t.s(3).unwrap_or_default(), pattern });
}
"STYLE" => {
@@ -178,7 +178,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
let gen_flags = t.i(71).unwrap_or(0);
let st = TextStyle {
name: name.clone(),
font: style_font(tg, t.s(3).unwrap_or_default()),
font: style_font(&tg, t.s(3).unwrap_or_default()),
big_font: t.s(4).unwrap_or_default(),
height: t.fd(40, 0.0),
width_factor: t.fd(41, 1.0),
@@ -186,7 +186,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
backwards: gen_flags & 2 != 0,
upside_down: gen_flags & 4 != 0,
vertical: t.i(70).unwrap_or(0) & 4 != 0,
annotative: annotative(tg),
annotative: annotative(&tg),
};
match style_index.get(&name.to_ascii_lowercase()).and_then(|&i| d.text_styles.get_mut(i)) {
Some(x) => *x = st,
@@ -230,7 +230,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
if !(center.x.is_finite() && center.y.is_finite()) {
continue;
}
let x = crate::dxf_ext::xdata(tg, crate::dxf_ext::APP);
let x = crate::dxf_ext::xdata(&tg, crate::dxf_ext::APP);
let field = |key: &str| {
x.iter().position(|t| t.code == 1000 && t.str() == key).and_then(|i| x.get(i + 1)).filter(|t| t.code == 1000).map(Tag::str)
};
@@ -274,8 +274,8 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
fields.insert(field.to_string(), v);
}
}
fields.extend(crate::dxf_ext::read_newer_dimvars(tg, &rx.styles, &rx.brs, &rx.ltypes));
let mut st = DimStyle { name: name.clone(), annotative: annotative(tg), ..DimStyle::default() };
fields.extend(crate::dxf_ext::read_newer_dimvars(&tg, &rx.styles, &rx.brs, &rx.ltypes));
let mut st = DimStyle { name: name.clone(), annotative: annotative(&tg), ..DimStyle::default() };
st.apply_fields(&fields);
match d.dim_styles.iter_mut().find(|s| s.name.eq_ignore_ascii_case(&name)) {
Some(x) => *x = st,
@@ -292,7 +292,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
d.vports.retain(|c| c.tiles.len() > usize::from(c.is_active()) || c.tiles.first().is_some_and(|t| t.twist != 0.0));
}
fn index_table_handles(recs: &[(String, &[Tag])], rx: &mut Rx) {
fn index_table_handles(recs: &[(String, Vec<Tag>)], rx: &mut Rx) {
for (kind, tags) in recs {
let table = T(tags);
let (Some(handle), Some(name)) = (table.s(5), table.s(2)) else { continue };
+34 -5
View File
@@ -3,7 +3,7 @@
//! the newer DIMSTYLE groups, and from 2007 in UTF-8 text (the caller picks the text encoding) and
//! MULTILEADER entities (older files get LEADER + MTEXT).
use std::collections::HashMap;
use std::collections::{HashMap, HashSet};
use cadcraft_color::Color;
use cadcraft_doc::{
@@ -39,6 +39,9 @@ use sections::tags_for;
struct W {
t: Vec<Tag>,
next: u64,
/// Handles the drawing's objects already hold: structural records skip them, so writing a
/// file whose own handles sit near the top of the range never repeats a handle (#913).
used: HashSet<u64>,
/// Upper-case plot style name → its `ACDBPLACEHOLDER` handle (group 390 of layers and objects).
pstyles: HashMap<String, String>,
/// Upper-case layer name → its LAYER table record handle (group 331/341 of viewports).
@@ -48,6 +51,21 @@ struct W {
reactors: HashMap<Handle, Vec<String>>,
}
/// Where the writer's own records (tables, objects, dictionaries) start numbering: above every
/// object handle and the drawing's seed, with headroom for handles the drawing allocates next.
fn structural_start(d: &Drawing) -> u64 {
let highest = entity_handles(d).max().unwrap_or(0);
d.handseed.max(0x100).max(highest.saturating_add(1)).saturating_add(0x1000)
}
/// Every handle an object holds, plus the drawing's next one.
fn entity_handles(d: &Drawing) -> impl Iterator<Item = u64> + '_ {
let model = d.model.iter().map(|e| e.handle.0);
let layouts = d.layouts.iter().flat_map(|l| l.entities.iter()).map(|e| e.handle.0);
let blocks = d.blocks.values().flat_map(|b| b.entities.iter()).map(|e| e.handle.0);
model.chain(layouts).chain(blocks).chain(std::iter::once(d.handseed))
}
impl W {
fn s(&mut self, c: i32, v: impl Into<String>) {
self.t.push(Tag::s(c, v));
@@ -71,10 +89,20 @@ impl W {
format!("{:X}", self.next_handle())
}
/// A new handle for a record the drawing doesn't hold (as [`W::h`]).
///
/// Skips every handle in use, so a file object carrying a handle above the seed (the
/// reserved band) is not handed out again, and wraps into that band if the writer runs off
/// the top of the range. Each handle skipped is one in use, so the walk is bounded by their
/// count.
fn next_handle(&mut self) -> u64 {
let h = self.next;
self.next = self.next.saturating_add(1);
h
for _ in 0..self.used.len().saturating_add(1) {
let h = self.next;
self.next = h.checked_add(1).unwrap_or(cadcraft_doc::HANDLE_LIMIT);
if self.used.insert(h) {
return h;
}
}
self.next
}
/// A `102 {NAME` … `102 }` group of handles.
fn group(&mut self, name: &str, code: i32, handles: &[&str]) {
@@ -152,7 +180,8 @@ fn bridge_markers(tags: &mut [Tag]) {
pub fn entity_groups(d: &Drawing, e: &Entity) -> (String, Vec<Tag>) {
let mut w = W {
t: Vec::new(),
next: d.handseed.max(0x100).saturating_add(0x1000),
next: structural_start(d),
used: entity_handles(d).collect(),
pstyles: HashMap::new(),
layers: HashMap::new(),
reactors: HashMap::new(),
+8 -1
View File
@@ -16,7 +16,14 @@ pub(super) fn annotative_xdata(w: &mut W) {
/// Override (`ACAD` DSTYLE) and associativity (`CADCRAFT` ASSOC) xdata of a dimension.
pub(super) fn dim_xdata(w: &mut W, dm: &Dimension, cx: &Ctx) {
let mut ov = W { t: Vec::new(), next: 0, pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() };
let mut ov = W {
t: Vec::new(),
next: 0,
used: std::collections::HashSet::new(),
pstyles: HashMap::new(),
layers: HashMap::new(),
reactors: HashMap::new(),
};
let mut sah = false;
for (k, v) in &dm.overrides {
let Some(field) = DimStyle::field_name(k) else { continue };
+9 -7
View File
@@ -7,9 +7,10 @@ use super::header::{code_page, header_vars};
use super::layout::{paper_views, record_head, sheet_first, table_head, vport_table};
use super::objects::{cadcraft_fonts_name, group_obj, mleader_style_obj, scale_list, table_style_obj};
use super::{
Block, Color, DimStyle, DimVal, Drawing, Entity, EntityKind, EntityStore, Group, HVal, Handle, HashMap, Layout, MLeaderStyle, PageSetup, Space,
TableStyle, Tag, Vec2, Vec3, Version, W, dxf_ext,
Block, Color, DimStyle, DimVal, Drawing, Entity, EntityKind, EntityStore, Group, HVal, Handle, HashMap, HashSet, Layout, MLeaderStyle, PageSetup,
Space, TableStyle, Tag, Vec2, Vec3, Version, W, dxf_ext,
};
use super::{entity_handles, structural_start};
struct TableWritePlan<'a> {
d: &'a Drawing,
@@ -245,7 +246,7 @@ fn write_dimstyles(w: &mut W, d: &Drawing, cx: &mut Ctx, version: Version) {
w.i(70, 0);
let v = serde_json::to_value(s).unwrap_or_default();
let defaults = serde_json::to_value(DimStyle::default()).unwrap_or_default();
let mut newer = W { t: Vec::new(), next: 0, pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() };
let mut newer = W { t: Vec::new(), next: 0, used: HashSet::new(), pstyles: HashMap::new(), layers: HashMap::new(), reactors: HashMap::new() };
for (field, code, kind) in dxf_ext::DIM_CODES {
let Some(enc) = v.get(*field).and_then(|x| cx.encode(*kind, x)) else { continue };
// DIMPOST is written even when empty: a reader that defaults a missing one to "<>"
@@ -916,7 +917,8 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
// Structural handles start above every entity handle.
let mut w = W {
t: Vec::new(),
next: d.handseed.max(0x100).saturating_add(0x1000),
next: structural_start(d),
used: entity_handles(d).collect(),
pstyles: HashMap::new(),
layers: HashMap::new(),
reactors: hatch_reactors(d),
@@ -1093,11 +1095,11 @@ pub(super) fn tags_for(d: &Drawing, version: Version, target: Version, frozen_34
for (n, h, b) in &user_blocks {
block(&mut w, (n, &b.description), h, b.base, if b.anonymous { 1 } else { 0 }, &mut b.entities.iter().map(|e| e.as_ref()), false);
}
// Generated geometry entities (dimension, arrowhead and table blocks) need handles.
// Generated geometry entities (dimension, arrowhead and table blocks) need handles; take
// them from the writer's allocator, which skips the drawing's own handles.
for (_, _, ents) in dim_defs.iter_mut().chain(arrow_defs.iter_mut()).chain(table_defs.iter_mut()) {
for e in ents.iter_mut().filter(|e| e.handle.0 == 0) {
e.handle = Handle(w.next);
w.next = w.next.saturating_add(1);
e.handle = Handle(w.next_handle());
}
}
for (n, h, ents) in &dim_defs {
+2 -2
View File
@@ -65,8 +65,8 @@ pub fn census(dxf: &[u8]) -> Option<Census> {
_ => {}
}
};
for s in craft_dxf::section_slices(&tags) {
let records = craft_dxf::record_slices(s.tags);
for s in craft_dxf::sections(&tags) {
let records = craft_dxf::records(&s.tags);
match s.name.trim().to_ascii_uppercase().as_str() {
"ENTITIES" => {
for (t, g) in &records {
+122 -16
View File
@@ -17,7 +17,7 @@ use std::collections::BTreeMap;
use cadcraft_color::Color;
use cadcraft_doc::{Circle, Common, Drawing, Ellipse, EntityKind, Layer, Line, LwPolyline, Space};
use cadcraft_geom::{Mat3, PolyVertex, Spline, Vec2, Vec3};
use cadcraft_geom::{Mat3, PolyVertex, Spline, Vec2, Vec3, bulge_to_arc};
use crate::{IoError, Result};
@@ -70,6 +70,8 @@ struct Parser {
verts_left: usize,
/// What was left out, by kind ([`LeftOut`]).
left_out: BTreeMap<LeftOut, usize>,
/// Shapes left out because their coordinates or extents overflow: invalid, not unsupported.
too_large: usize,
}
/// Drawn content the reader leaves out, named in the drawing's read note.
@@ -105,16 +107,23 @@ impl Parser {
elements: 0,
verts_left: MAX_TOTAL_VERTS,
left_out: BTreeMap::new(),
too_large: 0,
}
}
/// The read note on what was left out, if anything was.
fn note(&self) -> Option<String> {
if self.left_out.is_empty() {
return None;
/// The read notes on what was left out: what isn't read yet, then what is invalid.
fn notes(&self) -> Vec<String> {
let mut notes = Vec::new();
if !self.left_out.is_empty() {
let list: Vec<String> = self.left_out.iter().map(|(k, n)| k.describe(*n)).collect();
notes.push(format!("SVG: CADCraft doesn't read these yet, so they were left out: {}", list.join(", ")));
}
let list: Vec<String> = self.left_out.iter().map(|(k, n)| k.describe(*n)).collect();
Some(format!("SVG: CADCraft doesn't read these yet, so they were left out: {}", list.join(", ")))
match self.too_large {
0 => {}
1 => notes.push("SVG: 1 shape was left out as invalid: its coordinates or size are too large to represent".into()),
n => notes.push(format!("SVG: {n} shapes were left out as invalid: their coordinates or size are too large to represent")),
}
notes
}
fn parse(&mut self, text: &str) -> Result<()> {
@@ -150,7 +159,7 @@ impl Parser {
};
self.left_out.insert(kind, count);
}
self.drawing.read_notes.extend(self.note());
self.drawing.read_notes.extend(self.notes());
Ok(())
}
@@ -218,12 +227,18 @@ impl Parser {
}
// Charge the vertices this entity retains against the shared document budget, so repeated
// flattened arcs/curves cannot amplify a compact path into unbounded geometry (CWE-400).
// A shape left out below was generated all the same, so it is charged too.
let verts = match &kind {
EntityKind::LwPolyline(p) => p.vertices.len(),
EntityKind::Spline(s) => s.control.len(),
_ => 1,
};
self.verts_left = self.verts_left.checked_sub(verts).ok_or_else(|| IoError::Format("SVG: too much generated geometry".into()))?;
// Finite numbers can still overflow through transforms and relative steps (`l1e308 0` twice).
if !finite(&kind) {
self.too_large += 1;
return Ok(());
}
let common = Common { layer: self.layer.clone(), ..Common::default() };
self.drawing.add(&Space::Model, common, kind).map(|_| ()).map_err(parse_err)
}
@@ -231,7 +246,10 @@ impl Parser {
/// A circle or ellipse through a transform. A circle stays a `CIRCLE` under rotations,
/// uniform scales and reflections; anything else becomes an `ELLIPSE` holding the axes
/// of the transformed shape — a linear map sends the unit circle to an ellipse whose
/// semi-axes are the square roots of the eigenvalues of `A·Aᵀ`.
/// semi-axes are the square roots of the eigenvalues of `A·Aᵀ`. With `B = [bx by]` the
/// ellipse is `center + B·(cos t, sin t)`; `B·Bᵀ` lives in the drawing plane, so its leading
/// eigenvector is the major axis's direction. `major` is that axis from the centre, as
/// [`Ellipse::major`] is everywhere else.
fn add_rounded(&mut self, center_user: Vec2, rx: f64, ry: f64) -> Result<()> {
let center = self.map(center_user);
let bx = self.map_vec(Vec2::new(rx, 0.0));
@@ -253,18 +271,15 @@ impl Parser {
if s_max <= f64::EPSILON {
return Ok(());
}
let axis = if xy.abs() <= 1e-12 * trace.max(1.0) {
let axis = if xy.abs() <= 1e-12 * trace {
if yy > xx { Vec2::new(0.0, 1.0) } else { Vec2::new(1.0, 0.0) }
} else {
let v = Vec2::new(xy, l_max - xx);
let l = len(v);
if l <= f64::EPSILON {
return Ok(());
}
v / l
// |v| ≥ |xy| > 1e-12·trace ≥ 0 here, so the division is never by zero.
v / len(v)
};
let ratio = (l_min.max(0.0).sqrt() / s_max).clamp(1e-9, 1.0);
let major = center + axis * s_max;
let major = axis * s_max;
self.add(EntityKind::Ellipse(Ellipse { center: v3(center), major: v3(major), ratio, start: 0.0, end: std::f64::consts::TAU }))
}
@@ -380,6 +395,79 @@ impl Parser {
}
}
/// Every coordinate of an entity the reader makes is finite, and so are its extents: a finite
/// centre and radius can still reach past the largest number.
fn finite(kind: &EntityKind) -> bool {
match kind {
EntityKind::Line(l) => l.a.is_finite() && l.b.is_finite(),
EntityKind::Circle(c) => {
c.center.is_finite()
&& c.radius.is_finite()
&& cadcraft_geom::Circle::new(c.center.xy(), c.radius).bounds().corners().iter().all(|p| p.is_finite())
}
EntityKind::Ellipse(e) => {
// Half the box is `hypot` of the major axis and the minor axis (`ratio` times it, turned).
let (m, r) = (e.major.xy(), e.ratio);
e.center.is_finite() && e.major.is_finite() && e.ratio.is_finite() && box_finite(e.center.xy(), m.x.hypot(r * m.y), m.y.hypot(r * m.x))
}
EntityKind::LwPolyline(p) => p.vertices.iter().all(|v| v.p.is_finite() && v.bulge.is_finite()) && bulges_finite(p),
EntityKind::Spline(s) => s.control.iter().all(|p| p.is_finite()),
// The SVG reader doesn't make these.
EntityKind::Point(_)
| EntityKind::Arc(_)
| EntityKind::Polyline3d(_)
| EntityKind::Helix(_)
| EntityKind::Ray(_)
| EntityKind::XLine(_)
| EntityKind::Text(_)
| EntityKind::MText(_)
| EntityKind::AttDef(_)
| EntityKind::Insert(_)
| EntityKind::Dimension(_)
| EntityKind::MLine(_)
| EntityKind::Leader(_)
| EntityKind::MLeader(_)
| EntityKind::Hatch(_)
| EntityKind::Solid(_)
| EntityKind::Trace(_)
| EntityKind::Face3d(_)
| EntityKind::PolyfaceMesh(_)
| EntityKind::Region(_)
| EntityKind::Viewport(_)
| EntityKind::Image(_)
| EntityKind::Wipeout(_)
| EntityKind::Table(_)
| EntityKind::Tolerance(_)
| EntityKind::Unknown(_) => true,
}
}
/// The box `centre ± (hx, hy)` is finite.
fn box_finite(c: Vec2, hx: f64, hy: f64) -> bool {
[c.x - hx, c.x + hx, c.y - hy, c.y + hy].iter().all(|v| v.is_finite())
}
/// Every arc segment of the polyline (a bulge between finite vertices) has a finite centre and
/// radius, and the quadrant points it passes through are finite.
fn bulges_finite(p: &LwPolyline) -> bool {
let n = p.vertices.len();
p.vertices.iter().enumerate().all(|(i, v)| {
let next = if i + 1 < n {
p.vertices.get(i + 1)
} else if p.closed {
p.vertices.first()
} else {
None
};
let Some((arc, _)) = next.and_then(|w| bulge_to_arc(v.p, w.p, v.bulge)) else { return true };
arc.center.is_finite()
&& arc.radius.is_finite()
&& (0..4)
.map(|k| f64::from(k) * std::f64::consts::FRAC_PI_2)
.all(|a| !arc.contains_angle(a) || Vec2::polar(arc.center, arc.radius, a).is_finite())
})
}
/// One `M …` run of a `d` attribute.
struct Subpath {
start: Vec2,
@@ -471,4 +559,22 @@ mod tests {
assert_eq!(arc_of("M10 10 a20 20 0 1 0 20 20"), (true, false, spaced.2));
assert!(arc_of("M10 10 a20 20 0 10-20 20").0);
}
#[test]
fn extents_past_the_largest_number_are_not_finite() {
let ellipse = |c: Vec2, major: Vec2| EntityKind::Ellipse(Ellipse { center: v3(c), major: v3(major), ratio: 1.0, start: 0.0, end: 0.0 });
assert!(!finite(&ellipse(Vec2::new(1e308, 0.0), Vec2::new(1e308, 0.0))));
assert!(finite(&ellipse(Vec2::new(5e307, 0.0), Vec2::new(5e307, 0.0))));
// Turned, its box is wider than its axis: `centre ± major` is finite, the box isn't.
assert!(!finite(&ellipse(Vec2::new(6e307, 0.0), Vec2::new(9e307, 9e307))));
assert!(finite(&ellipse(Vec2::ZERO, Vec2::new(9e307, 9e307))));
// Half circles between the same finite points: bulging up passes 1.8e308, down doesn't.
let half = |bulge: f64| {
let (a, b) = (Vec2::new(0.0, 1.5e308), Vec2::new(1e308, 1.5e308));
let vertices = vec![PolyVertex::with_bulge(a, bulge), PolyVertex::new(b)];
EntityKind::LwPolyline(LwPolyline { vertices, closed: false, const_width: 0.0, elevation: 0.0, plinegen: false })
};
assert!(!finite(&half(-1.0)));
assert!(finite(&half(1.0)));
}
}
+117 -1
View File
@@ -2915,12 +2915,75 @@ fn svg_shapes_become_entities_in_millimetres() {
let c = first(&d, |k| if let EntityKind::Circle(c) = k { Some(c.clone()) } else { None });
assert!((c.radius - 2.0).abs() < 1e-9 && (c.center.x - 10.0).abs() < 1e-9 && (c.center.y - 5.0).abs() < 1e-9, "{c:?}");
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
let major = Vec2::new(e.major.x - e.center.x, e.major.y - e.center.y);
let major = Vec2::new(e.major.x, e.major.y);
assert!((major.len() - 4.0).abs() < 1e-9 && (e.ratio - 0.5).abs() < 1e-9, "{e:?}");
let l = first(&d, |k| if let EntityKind::Line(l) = k { Some(l.clone()) } else { None });
assert!((l.a.y - 10.0).abs() < 1e-9 && (l.b.y).abs() < 1e-9, "{l:?}");
}
#[test]
fn svg_ellipse_major_axis_is_relative_to_its_centre() {
// Away from the origin: the major axis was stored as the absolute point centre + axis.
let svg = format!("{SVG_PAGE}<ellipse cx=\"15\" cy=\"2\" rx=\"2\" ry=\"1\"/><circle cx=\"15\" cy=\"2\" r=\"1\"/></svg>");
let d = read(svg.as_bytes(), "ellipse.svg").unwrap();
assert_eq!(kinds(&d), ["Ellipse", "Circle"]);
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
assert!((e.center - Vec3::new(15.0, 8.0, 0.0)).len() < 1e-9, "{e:?}");
assert!((e.major.x.abs() - 2.0).abs() < 1e-9 && e.major.y.abs() < 1e-9 && e.major.z == 0.0, "{e:?}");
assert!((e.ratio - 0.5).abs() < 1e-9, "{e:?}");
let c = first(&d, |k| if let EntityKind::Circle(c) = k { Some(c.clone()) } else { None });
assert!((c.center - Vec3::new(15.0, 8.0, 0.0)).len() < 1e-9 && (c.radius - 1.0).abs() < 1e-9, "{c:?}");
}
#[test]
fn svg_rotated_ellipse_keeps_its_turn() {
// The page maps SVG (x, y) to (x, 10 - y); undo that, then rotate by -30°, to get back to the ellipse's own frame.
let svg = format!("{SVG_PAGE}<ellipse cx=\"0\" cy=\"0\" rx=\"20\" ry=\"10\" transform=\"rotate(30)\"/></svg>");
let d = read(svg.as_bytes(), "rotated.svg").unwrap();
assert_eq!(kinds(&d), ["Ellipse"]);
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
let major = Vec2::new(e.major.x, e.major.y);
assert!((major.len() - 20.0).abs() < 1e-9 && (e.ratio - 0.5).abs() < 1e-9, "{e:?}");
let (s, c) = 30f64.to_radians().sin_cos();
let want = Vec2::new(20.0 * c, -20.0 * s);
assert!((major - want).len() < 1e-9 || (major + want).len() < 1e-9, "{e:?}");
let (ux, uy) = (e.center.x + major.x, 10.0 - (e.center.y + major.y));
let (x, y) = (c * ux + s * uy, -s * ux + c * uy);
assert!(((x / 20.0).powi(2) + (y / 10.0).powi(2) - 1.0).abs() < 1e-9, "{e:?}");
}
#[test]
fn svg_sheared_circle_has_the_axes_of_its_image() {
// matrix(1 0 1 1 0 0) is B = [[1, 1], [0, 1]]; the page then flips Y at one millimetre per unit.
let svg = format!("{SVG_PAGE}<circle r=\"1\" transform=\"matrix(1 0 1 1 0 0)\"/></svg>");
let d = read(svg.as_bytes(), "sheared.svg").unwrap();
assert_eq!(kinds(&d), ["Ellipse"]);
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
let major = Vec2::new(e.major.x, e.major.y);
let s_max = ((3.0 + 5f64.sqrt()) / 2.0).sqrt();
let s_min = ((3.0 - 5f64.sqrt()) / 2.0).sqrt();
assert!((major.len() - s_max).abs() < 1e-9 * s_max, "{e:?}");
assert!((e.ratio - s_min / s_max).abs() < 1e-9, "{e:?}");
let (ux, uy) = (major.x, -major.y);
let pre = Vec2::new(ux - uy, uy);
assert!((pre.len() - 1.0).abs() < 1e-9, "B⁻¹·major = {pre:?}, {e:?}");
assert!(major.x.abs() > 1e-3 && major.y.abs() > 1e-3, "{e:?}");
}
#[test]
fn svg_tiny_sheared_circle_has_the_axes_of_its_image() {
// Columns (1, 0.5)·1e-6 and (1, -0.5)·1e-6: far from orthogonal, though their dot product is tiny.
let svg = format!("{SVG_PAGE}<circle r=\"1\" transform=\"matrix(1e-6 0.5e-6 1e-6 -0.5e-6 0 0)\"/></svg>");
let d = read(svg.as_bytes(), "tiny.svg").unwrap();
assert_eq!(kinds(&d), ["Ellipse"]);
let e = first(&d, |k| if let EntityKind::Ellipse(e) = k { Some(e.clone()) } else { None });
let major = Vec2::new(e.major.x, e.major.y);
assert!(major.y.abs() <= 1e-9 * major.x.abs(), "{e:?}");
let want = 2f64.sqrt() * 1e-6;
assert!((major.len() - want).abs() < 1e-9 * want, "{e:?}");
assert!((e.ratio - 0.5).abs() < 1e-9, "{e:?}");
}
#[test]
fn svg_path_lines_curves_and_arcs() {
let svg = format!("{SVG_PAGE}<path d=\"M1 1 L5 1 C6 1 7 2 8 3\"/><path d=\"M0 0 A5 5 0 0 1 10 0 Z\"/></svg>");
@@ -3137,6 +3200,59 @@ fn svg_hostile_input_errors_without_panicking() {
assert!(deep.is_err(), "200 nested groups are refused, not walked");
}
#[test]
fn svg_coordinates_that_overflow_are_left_out() {
// Every number is finite; relative steps and transforms overflow them to infinity or NaN.
let svg = format!(
"{SVG_PAGE}<path d=\"M1e308 0 l1e308 0\"/><rect x=\"1e308\" width=\"1e308\" height=\"1\"/>\
<g transform=\"scale(1e308)\"><line x1=\"1e308\" y1=\"0\" x2=\"1\" y2=\"1\"/><circle r=\"1e308\"/></g>\
<g transform=\"scale(1e308,1)\"><ellipse rx=\"1e308\" ry=\"1\"/><path d=\"M0 0 C1e308 0 1 1 2 2\"/></g>\
<line x1=\"0\" y1=\"0\" x2=\"1\" y2=\"1\"/></svg>"
);
let d = read(svg.as_bytes(), "huge.svg").unwrap();
assert_eq!(kinds(&d), ["Line"]);
assert_eq!(d.read_notes, ["SVG: 6 shapes were left out as invalid: their coordinates or size are too large to represent"]);
}
#[test]
fn svg_shapes_whose_extents_overflow_are_left_out() {
// A finite centre and radius whose sum overflows; the same scale on smaller values stays
// representable.
let svg = format!("{SVG_PAGE}<g transform=\"scale(1e308)\"><circle cx=\"1\" cy=\"0\" r=\"1\"/><circle cx=\"0.5\" cy=\"0\" r=\"0.5\"/></g></svg>");
let d = read(svg.as_bytes(), "huge.svg").unwrap();
assert_eq!(kinds(&d), ["Circle"]);
let c = first(&d, |k| if let EntityKind::Circle(c) = k { Some(c.clone()) } else { None });
assert!((c.radius - 5e307).abs() < 1e293, "{}", c.radius);
assert_eq!(d.read_notes, ["SVG: 1 shape was left out as invalid: its coordinates or size are too large to represent"]);
}
/// A shape too large to represent is invalid, not something CADCraft doesn't read yet: it gets a
/// note of its own.
#[test]
fn svg_too_large_shapes_are_noted_apart_from_unread_content() {
let svg = format!("{SVG_PAGE}<text x=\"0\" y=\"5\">one</text><path d=\"M1e308 0 l1e308 0\"/><line x1=\"0\" y1=\"0\" x2=\"1\" y2=\"1\"/></svg>");
let d = read(svg.as_bytes(), "huge.svg").unwrap();
assert_eq!(kinds(&d), ["Line"]);
assert_eq!(
d.read_notes,
[
"SVG: CADCraft doesn't read these yet, so they were left out: 1 text",
"SVG: 1 shape was left out as invalid: its coordinates or size are too large to represent"
]
);
}
#[test]
fn svg_shapes_left_out_still_count_against_the_vertex_budget() {
// Each arc flattens to 10,000 chords under the non-uniform scale, and the doubled translation
// overflows to infinity, so each is left out; 820 of them make more than the 8,000,000 vertices
// a file may generate.
let arcs = "A1e9 1e9 0 0 1 2e9 0 A1e9 1e9 0 0 1 0 0 ".repeat(410);
let svg = format!("{SVG_PAGE}<g transform=\"translate(1e308 0) translate(1e308 0) scale(2 1)\"><path d=\"M0 0 {arcs}\"/></g></svg>");
let err = read(svg.as_bytes(), "huge.svg").err().map(|e| e.to_string()).unwrap_or_default();
assert!(err.contains("SVG: too much generated geometry"), "{err}");
}
#[test]
fn svg_no_geometry_yields_an_empty_drawing() {
let svg = format!("{SVG_PAGE}</svg>");
+360
View File
@@ -0,0 +1,360 @@
//! A hostile or damaged file can name a handle at the top of the range: an object's own handle,
//! or its `$HANDSEED`. A file's handles keep their identity, so a new object must take a free
//! handle instead of replacing the file's own object (#913).
#![cfg(not(target_arch = "wasm32"))]
use cadcraft_doc::{Common, DimKind, Dimension, Drawing, Entity, EntityKind, Handle, Line, Space};
use cadcraft_geom::Vec3;
const TOP: &str = "FFFFFFFFFFFFFFFF";
const NEAR_TOP: &str = "FFFFFFFFFFFEFFFF";
fn read(text: &str) -> Drawing {
cadcraft_io::read_dxf(text.as_bytes()).unwrap()
}
fn line(x: f64, y: f64) -> EntityKind {
EntityKind::Line(Line { a: Vec3::new(x, y, 0.0), b: Vec3::new(x + 1.0, y, 0.0) })
}
/// One line, with `entity_handle` when given, under a `$HANDSEED` of `seed`.
fn dxf(entity_handle: Option<&str>, seed: &str) -> String {
let handle = entity_handle.map(|h| format!("5\n{h}\n")).unwrap_or_default();
format!(
"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1032\n9\n$HANDSEED\n5\n{seed}\n0\nENDSEC\n\
0\nSECTION\n2\nENTITIES\n0\nLINE\n{handle}8\n0\n10\n0.0\n20\n0.0\n30\n0.0\n11\n1.0\n21\n0.0\n31\n0.0\n0\nENDSEC\n0\nEOF\n"
)
}
fn distinct(d: &Drawing) -> Vec<Handle> {
d.model.iter().map(|e| e.handle).collect()
}
#[test]
fn an_object_at_the_top_of_the_handle_range_is_not_replaced_by_a_new_one() {
let mut d = read(&dxf(Some(TOP), TOP));
assert_eq!(d.model.len(), 1);
// The file's handle is its own; the new object takes a free handle below it.
assert!(d.entity(Handle::parse_hex(TOP).unwrap()).is_some(), "the file's handle was renumbered");
d.add(&Space::Model, Common::default(), line(10.0, 10.0)).unwrap();
assert_eq!(d.model.len(), 2, "the file's line was replaced by the new one");
let handles = distinct(&d);
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the file's line is gone");
}
#[test]
fn a_seed_at_the_top_of_the_handle_range_cannot_be_followed_twice() {
let mut d = read(&dxf(None, TOP));
let a = d.add(&Space::Model, Common::default(), line(0.0, 10.0)).unwrap();
let b = d.add(&Space::Model, Common::default(), line(0.0, 20.0)).unwrap();
assert_ne!(a, b, "two objects were given the same handle");
assert_eq!(d.model.len(), 3, "the second line replaced the first");
}
#[test]
fn an_ordinary_high_handle_keeps_its_identity() {
// Far below the top of the range a file's handles are its own: they stay as they are.
let h = "FFFFFFFF";
let mut d = read(&dxf(Some(h), h));
assert!(d.entity(Handle::parse_hex(h).unwrap()).is_some(), "the file's handle was renumbered");
let n = d.add(&Space::Model, Common::default(), line(0.0, 5.0)).unwrap();
assert!(n.0 > Handle::parse_hex(h).unwrap().0, "a new handle below the file's own");
}
#[test]
fn a_handle_just_below_the_top_survives_a_save() {
// Main keeps a file's handles exactly as written, even near the top of the range: handles
// are how other objects and other programs refer to an entity (#939's round-trip tests).
let mut d = read(&dxf(Some(NEAR_TOP), NEAR_TOP));
let n = d.add(&Space::Model, Common::default(), line(0.0, 5.0)).unwrap();
let bytes = cadcraft_io::write(&d, "near-top.dxf").unwrap();
let r = cadcraft_io::read_dxf(&bytes).unwrap();
assert!(r.entity(Handle::parse_hex(NEAR_TOP).unwrap()).is_some(), "the file's handle did not survive the save");
assert!(r.entity(n).is_some(), "the new handle did not survive the save");
}
#[test]
fn nine_objects_drawn_after_a_saturated_seed_save_and_reopen_distinct() {
// The nine-entity case from #2237: a saturated $HANDSEED, ordinary entity handles. Drawing
// after the load gives every object its own handle, and a save/reopen keeps them apart.
let mut d = read(&dxf(None, TOP));
for i in 0..9 {
d.add(&Space::Model, Common::default(), line(f64::from(i), 40.0)).unwrap();
}
let bytes = cadcraft_io::write(&d, "nine.dxf").unwrap();
let r = cadcraft_io::read_dxf(&bytes).unwrap();
assert_eq!(r.model.len(), 10, "the file's line and the nine drawn ones");
let handles = distinct(&r);
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
assert_eq!(unique.len(), handles.len(), "repeated handles on reopen: {handles:?}");
}
/// The first handle in the reserved band above [`HANDLE_LIMIT`].
const BAND: &str = "FFFFFFFF00000000";
#[test]
fn a_seed_in_the_reserved_band_does_not_hand_out_the_files_handle() {
// #913's remaining case: a file says its next handle is FFFFFFFF00000000 and an object holds
// that handle. Following the seed once would hand the object's handle to the new object, and
// `EntityStore` would replace the file's line.
let mut d = read(&dxf(Some(BAND), BAND));
assert_eq!(d.model.len(), 1);
let n = d.add(&Space::Model, Common::default(), line(10.0, 10.0)).unwrap();
assert_ne!(n, Handle::parse_hex(BAND).unwrap(), "the new object took the file object's handle");
assert_eq!(d.model.len(), 2, "the file's line was replaced");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the file's line is gone");
let bytes = cadcraft_io::write(&d, "band-seed.dxf").unwrap();
let r = cadcraft_io::read_dxf(&bytes).unwrap();
let handles = distinct(&r);
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
assert_eq!(unique.len(), handles.len(), "repeated handles on reopen: {handles:?}");
assert_eq!(r.model.len(), 2, "a line did not survive the save");
}
#[test]
fn a_save_does_not_give_a_structural_record_an_objects_handle() {
// The writer numbers its own records from `seed + 0x1000`; with the seed at the bottom of the
// reserved band that lands on the file's own handle. The file must keep one record per handle.
let object = "FFFFFFFF00001000";
let d = read(&dxf(Some(object), "FFFFFFFEFFFFFFFF"));
let bytes = cadcraft_io::write(&d, "band-structural.dxf").unwrap();
let tags = craft_dxf::parse(&bytes).unwrap();
// Record handles start with the TABLES section; before it the HEADER's `$HANDSEED` is the
// next free handle, not a record's.
let after_header = tags.iter().position(|t| t.code == 2 && t.str() == "TABLES").unwrap();
let written: Vec<String> = tags[after_header..].iter().filter(|t| t.code == 5 || t.code == 105).map(|t| t.str().to_string()).collect();
let unique: std::collections::HashSet<&String> = written.iter().collect();
assert_eq!(unique.len(), written.len(), "the save repeats a handle: {written:?}");
assert_eq!(written.iter().filter(|h| h.as_str() == object).count(), 1, "the object's handle was not written exactly once");
let r = cadcraft_io::read_dxf(&bytes).unwrap();
assert!(r.entity(Handle::parse_hex(object).unwrap()).is_some(), "the file's object is gone");
}
/// A CADCraft-marked file with a handle-less block entity and an `ENTITIES` record that names
/// the handle the reader would give it. The marker means the reader skips the handle pre-scan,
/// so the two sections must still reserve against each other.
fn marked_file_with_handle_less_block_entity() -> String {
"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1032\n9\n$HANDSEED\n5\n1000\n0\nENDSEC\n\
0\nSECTION\n2\nBLOCKS\n\
0\nBLOCK\n8\n0\n2\n*MODEL_SPACE\n70\n0\n10\n0.0\n20\n0.0\n30\n0.0\n3\n*MODEL_SPACE\n1\n\n\
0\nLINE\n8\n0\n10\n0.0\n20\n0.0\n30\n0.0\n11\n1.0\n21\n0.0\n31\n0.0\n\
0\nENDBLK\n8\n0\n\
0\nENDSEC\n\
0\nSECTION\n2\nENTITIES\n\
0\nLINE\n5\n100\n8\n0\n10\n10.0\n20\n0.0\n30\n0.0\n11\n11.0\n21\n0.0\n31\n0.0\n\
0\nENDSEC\n\
0\nSECTION\n2\nOBJECTS\n\
0\nXRECORD\n5\n300\n100\nAcDbXrecord\n3\nCADCRAFT_HANDSEED\n1\n1000\n\
0\nENDSEC\n0\nEOF\n"
.to_string()
}
#[test]
fn a_marked_files_sections_reserve_handles_against_each_other() {
// The block entity has no handle of its own, so the reader gives it one; a later ENTITIES
// record must not be given the same handle, or one entity silently replaces the other.
let d = read(&marked_file_with_handle_less_block_entity());
assert_eq!(d.model.len(), 2, "one entity replaced the other");
let handles = distinct(&d);
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the block entity is gone");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 10.0)), "the ENTITIES line is gone");
}
/// A file whose BLOCKS holds a handle-less model-space entity and whose ENTITIES names the
/// last handle below the reserved band and the first handle in it. With `marked` the file names
/// CADCraft's own seed record, which narrows the reader's handle pre-scan to the entity sections.
fn file_with_reserved_band_entities(marked: bool) -> String {
let below = format!("{:X}", cadcraft_doc::HANDLE_LIMIT - 1);
let band = format!("{:X}", cadcraft_doc::HANDLE_LIMIT);
let objects = if marked {
"0\nSECTION\n2\nOBJECTS\n\
0\nXRECORD\n5\n300\n100\nAcDbXrecord\n3\nCADCRAFT_HANDSEED\n1\n1000\n\
0\nENDSEC\n"
} else {
""
};
format!(
"0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1032\n9\n$HANDSEED\n5\n1000\n0\nENDSEC\n\
0\nSECTION\n2\nBLOCKS\n\
0\nBLOCK\n8\n0\n2\n*MODEL_SPACE\n70\n0\n10\n0.0\n20\n0.0\n30\n0.0\n3\n*MODEL_SPACE\n1\n\n\
0\nLINE\n8\n0\n10\n0.0\n20\n0.0\n30\n0.0\n11\n1.0\n21\n0.0\n31\n0.0\n\
0\nENDBLK\n8\n0\n\
0\nENDSEC\n\
0\nSECTION\n2\nENTITIES\n\
0\nLINE\n5\n{below}\n8\n0\n10\n10.0\n20\n0.0\n30\n0.0\n11\n11.0\n21\n0.0\n31\n0.0\n\
0\nLINE\n5\n{band}\n8\n0\n10\n20.0\n20\n0.0\n30\n0.0\n11\n21.0\n21\n0.0\n31\n0.0\n\
0\nENDSEC\n{objects}0\nEOF\n"
)
}
/// All three lines survive with their own handles: the handle-less block entity could not take
/// the reserved-band handle of the file's own ENTITIES record.
fn assert_three_lines_survive(d: &Drawing) {
assert_eq!(d.model.len(), 3, "one entity replaced another");
let handles = distinct(d);
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 0.0)), "the block entity is gone");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 10.0)), "the line below the band is gone");
assert!(d.model.iter().any(|e| matches!(e.kind, EntityKind::Line(ref l) if l.a.x == 20.0)), "the line in the band is gone");
// The band's explicit handle stays with the record that names it.
let band = Handle(cadcraft_doc::HANDLE_LIMIT);
let owner = d.model.iter().find(|e| e.handle == band).expect("the band handle was renumbered");
assert!(matches!(&owner.kind, EntityKind::Line(l) if l.a.x == 20.0), "the band handle moved to another line");
// The handle just below the band is the file's too, and it stays with its own record.
let below = Handle(cadcraft_doc::HANDLE_LIMIT - 1);
let owner = d.model.iter().find(|e| e.handle == below).expect("the below-band handle was renumbered");
assert!(matches!(&owner.kind, EntityKind::Line(l) if l.a.x == 10.0), "the below-band handle moved to another line");
}
#[test]
fn reserved_band_handles_in_entities_are_not_handed_to_a_handle_less_block_entity() {
// The handle below the reserved band is the file's, so the reader's next handle is the first
// handle in the band, which an ENTITIES record already owns. The seed cannot follow it
// (#913), so the handle is reserved for allocation instead: the handle-less model-space
// block entity must not take it and replace the file's line.
assert_three_lines_survive(&read(&file_with_reserved_band_entities(true)));
}
#[test]
fn reserved_band_handles_are_reserved_without_the_cadcraft_seed_record() {
// The same reservation holds when the pre-scan reads every section's handles: a handle in
// the band is the file's own there too, and still must not be given away.
assert_three_lines_survive(&read(&file_with_reserved_band_entities(false)));
}
#[test]
fn reservations_end_with_the_read_and_placed_objects_still_keep_their_handles() {
// The reservations only bridge the gap until a record is placed; a drawing does not carry
// them on (every undo step copies the drawing). The placed objects keep new ones off.
let mut d = read(&file_with_reserved_band_entities(true));
assert!(d.reserved_handles.is_empty(), "the reader's reservations outlived the read");
for i in 0..3 {
d.add(&Space::Model, Common::default(), line(f64::from(i), 50.0)).unwrap();
}
assert_eq!(d.model.len(), 6, "a new object replaced one of the file's");
assert_three_lines_survive_among(&d);
}
fn assert_three_lines_survive_among(d: &Drawing) {
let band = Handle(cadcraft_doc::HANDLE_LIMIT);
assert!(d.model.iter().any(|e| e.handle == band && matches!(&e.kind, EntityKind::Line(l) if l.a.x == 20.0)), "the band line lost its handle");
let handles = distinct(d);
let unique: std::collections::HashSet<Handle> = handles.iter().copied().collect();
assert_eq!(unique.len(), handles.len(), "duplicate handles: {handles:?}");
}
#[test]
fn generated_geometry_never_takes_a_handle_an_object_holds() {
// The drawing's own handles sit in the reserved band and the seed is at the top of the
// range, so the writer's structural numbering wraps into the band. Every other band handle
// is taken, so without a check the generated dimension block's entities land on an occupied
// one: the saved file would repeat a handle.
let mut d = Drawing::new_imperial();
d.handseed = u64::MAX - 1;
{
let model = d.space_mut(&Space::Model).unwrap();
for i in 0..200u64 {
let handle = Handle(cadcraft_doc::HANDLE_LIMIT + 1 + 2 * i);
model.push(Entity { handle, common: Common::default(), kind: line(i as f64, 0.0) });
}
model.push(Entity {
handle: Handle(0x200),
common: Common::default(),
kind: EntityKind::Dimension(Dimension {
kind: DimKind::Linear { rotation: 0.0 },
defpt: Vec3::new(0.0, 1.0, 0.0),
text_mid: Vec3::new(1.0, 1.0, 0.0),
p13: Vec3::ZERO,
p14: Vec3::new(2.0, 0.0, 0.0),
p15: Vec3::ZERO,
p16: Vec3::ZERO,
text: String::new(),
style: "Standard".into(),
measurement: 2.0,
text_rotation: 0.0,
user_text_pos: false,
block: None,
insertion_point: Vec3::ZERO,
overrides: serde_json::Map::new(),
assoc: Vec::new(),
marks: Default::default(),
}),
});
}
let bytes = cadcraft_io::write(&d, "generated.dxf").unwrap();
let tags = craft_dxf::parse(&bytes).unwrap();
let after_header = tags.iter().position(|t| t.code == 2 && t.str() == "TABLES").unwrap();
let written: Vec<String> = tags[after_header..].iter().filter(|t| t.code == 5 || t.code == 105).map(|t| t.str().to_string()).collect();
let unique: std::collections::HashSet<&String> = written.iter().collect();
assert_eq!(unique.len(), written.len(), "the save repeats a handle");
}
/// A line at the top handle with another application's xdata, and that application's object kept
/// from the file: a dictionary in the named object dictionary holding an XRECORD.
fn top_line_with_kept_objects() -> String {
let groups: &[(i32, &str)] = &[
(0, "SECTION"),
(2, "ENTITIES"),
(0, "LINE"),
(5, TOP),
(8, "0"),
(10, "0"),
(20, "0"),
(11, "10"),
(21, "0"),
(1001, "OTHER_APP"),
(1000, "tagged"),
(0, "ENDSEC"),
(0, "SECTION"),
(2, "OBJECTS"),
(0, "DICTIONARY"),
(5, "C"),
(330, "0"),
(100, "AcDbDictionary"),
(3, "OTHER_APP"),
(350, "50"),
(0, "DICTIONARY"),
(5, "50"),
(330, "C"),
(100, "AcDbDictionary"),
(281, "1"),
(3, "DATA"),
(360, "51"),
(0, "XRECORD"),
(5, "51"),
(330, "50"),
(100, "AcDbXrecord"),
(280, "1"),
(1, "kept"),
(0, "ENDSEC"),
(0, "EOF"),
];
groups.iter().map(|(c, v)| format!("{c}\n{v}\n")).collect()
}
#[test]
fn records_added_on_save_after_the_top_handle_take_free_handles() {
// The writer adds the kept objects (and any application id the xdata needs) after its own
// records, numbered above the largest handle written. That is the file's line at the top of
// the range: counting on from it would give every added record the line's handle.
let d = read(&top_line_with_kept_objects());
let bytes = cadcraft_io::write(&d, "kept-top.dxf").unwrap();
let text = String::from_utf8_lossy(&bytes);
assert!(text.contains("\nkept"), "the kept XRECORD was not written");
let tags = craft_dxf::parse(&bytes).unwrap();
let after_header = tags.iter().position(|t| t.code == 2 && t.str() == "TABLES").unwrap();
let written: Vec<String> = tags[after_header..].iter().filter(|t| t.code == 5 || t.code == 105).map(|t| t.str().to_string()).collect();
let unique: std::collections::HashSet<&String> = written.iter().collect();
assert_eq!(unique.len(), written.len(), "the save repeats a handle: {written:?}");
assert_eq!(written.iter().filter(|h| h.as_str() == TOP).count(), 1, "the line's handle was not written exactly once");
let r = read(&String::from_utf8_lossy(&bytes));
assert!(r.entity(Handle::parse_hex(TOP).unwrap()).is_some(), "the file's line is gone");
}
@@ -26,7 +26,6 @@ fn preserves_or_refuses(path: &str, binary: bool) {
}
#[test]
#[ignore = "Confirmed DXF data loss: exhausted generated handles produce a successful save that reopens with no model entities"]
fn dxf_exhausted_handles_are_preserved_or_refused() {
for binary in [false, true] {
preserves_or_refuses("memory.dxf", binary);
@@ -16,8 +16,8 @@ fn import(transform: &str) -> (f64, f64) {
_ => None,
})
.unwrap();
let (dx, dy) = (e.major.x - e.center.x, e.major.y - e.center.y);
(dy.atan2(dx), e.ratio)
// `major` is the axis from the centre (#2821).
(e.major.y.atan2(e.major.x), e.ratio)
}
/// Major-axis angle and ratio of the image of the ellipse under the 2x2 map `[a c; b d]`, with
+9 -29
View File
@@ -2,11 +2,9 @@
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{Ipv4Addr, SocketAddr, TcpStream, ToSocketAddrs};
use std::sync::Arc;
use std::time::Duration;
use cadcraft_engine::Session;
use cadcraft_engine::file_access::{self, AutomationRoots};
use serde_json::{Value, json};
/// Something that answers control-channel methods (`engine.execute`, `cmdline.input`,
@@ -300,7 +298,6 @@ impl Backend for Remote {
fn has_ui(&self) -> bool {
true
}
/// What this backend talks to, for messages.
fn describe(&self) -> String {
format!("connected to CADCraft at {}", self.addr)
}
@@ -324,19 +321,13 @@ const HEADLESS_METHODS: &[(&str, &str, &str)] = &[
];
/// An in-process headless session (no window).
#[derive(Default)]
pub struct Headless {
pub session: Session,
/// The folders its methods may read and write (`--automation-read-root`,
/// `--automation-write-root`); `None`: anywhere.
roots: Option<Arc<AutomationRoots>>,
}
impl Headless {
/// Confine the files every method reads and writes to `roots` ([`file_access`]).
pub fn with_automation_roots(mut self, roots: Option<Arc<AutomationRoots>>) -> Self {
self.roots = roots;
self
impl Default for Headless {
fn default() -> Self {
Headless { session: Session::new() }
}
}
@@ -355,9 +346,8 @@ fn state(s: &Session) -> Value {
})
}
impl Headless {
/// The reply to one control method; the caller holds it to the roots.
fn answer(&mut self, method: &str, p: &Value) -> Result<Value, String> {
impl Backend for Headless {
fn call(&mut self, method: &str, p: Value) -> Result<Value, String> {
let s = &mut self.session;
let str_p = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
match method {
@@ -417,14 +407,14 @@ impl Headless {
"engine.commands" => {
Ok(Value::Array(cadcraft_engine::command_specs().iter().map(|c| serde_json::to_value(c.info(s)).unwrap_or_default()).collect()))
}
"drawing.inspect" | "document.inspect" => s.execute("drawing.inspect", p).map_err(|e| e.to_string()),
"drawing.inspect" | "document.inspect" => s.execute("drawing.inspect", &p).map_err(|e| e.to_string()),
"ui.render" => {
let w = p.get("width").and_then(Value::as_f64).unwrap_or(1600.0).clamp(16.0, 8192.0) as u32;
let h = p.get("height").and_then(Value::as_f64).unwrap_or(1000.0).clamp(16.0, 8192.0) as u32;
let st = s.state().map_err(|e| e.to_string())?;
let window = render_window(p);
let window = render_window(&p);
// `background` and `plot_style` (#803), read as the app reads them.
let look = cadcraft_engine::render_look::RenderLook::from_params(&st.doc, p)?;
let look = cadcraft_engine::render_look::RenderLook::from_params(&st.doc, &p)?;
let opts = cadcraft_render::Options {
view: window,
transparency: s.settings.transparency_display,
@@ -447,7 +437,6 @@ impl Headless {
let mut r =
json!({"pngBase64": cadcraft_engine::cmd::file::base64_encode(&png), "width": w, "height": h, "truncated": list.truncated});
if let Some(path) = str_p("path") {
file_access::check_write(&path)?;
let file = std::path::Path::new(&path);
let folder = cadcraft_engine::atomic_write::missing_folder(file);
cadcraft_engine::atomic_write::write_atomic_making_folders(file, &png).map_err(|e| format!("{path}: {e}"))?;
@@ -463,7 +452,7 @@ impl Headless {
}
"app.save" => {
let id = if p.get("path").is_some() { "saveas" } else { "qsave" };
s.execute(id, p).map_err(|e| e.to_string())
s.execute(id, &p).map_err(|e| e.to_string())
}
"ui.screenshot" => Err("no UI in headless mode; use render".into()),
"control.methods" => Ok(HEADLESS_METHODS
@@ -474,18 +463,9 @@ impl Headless {
other => Err(format!("unknown method `{other}`; `control.methods` lists them (docs/control-protocol.md)")),
}
}
}
impl Backend for Headless {
/// Run one control method inside the roots, if any.
fn call(&mut self, method: &str, p: Value) -> Result<Value, String> {
let roots = self.roots.clone();
file_access::confine(roots.as_ref(), || self.answer(method, &p))
}
fn has_ui(&self) -> bool {
false
}
/// What this backend talks to, for messages.
fn describe(&self) -> String {
"headless CADCraft session".into()
}
-36
View File
@@ -412,39 +412,3 @@ fn legacy_protocol_routing_and_version_negotiation() {
json!([{"jsonrpc":"2.0","id":[1],"result":{}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"missing `method`"}}])
);
}
/// With a read root and no write root (the read-only use #1931 asks for), an agent still draws,
/// reads and renders, but no route writes a file outside: the save tool, `execute` of the
/// writers, a save hidden mid-line at the command line and one in a script. Carried from #1973's
/// read-only mode tests.
#[test]
fn a_read_root_alone_still_draws_but_writes_nothing() {
let base = std::env::temp_dir().join(format!("cc-mcp-readonly-{}", std::process::id()));
let (inside, outside) = (base.join("in"), base.join("outside"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
let roots = cadcraft_engine::file_access::AutomationRoots::new(Some(&inside), None).unwrap();
let mut s = Server::new(Box::new(Headless::default().with_automation_roots(roots)));
let _ = call(&mut s, 1, "initialize", json!({"protocolVersion": "2025-06-18"}));
let _ = s.handle_line(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);
tool(&mut s, "command_line", json!({"text": "rectang 0,0 100,60"}));
tool(&mut s, "execute", json!({"command": "circle", "params": {"center": [10, 10], "radius": 4}}));
assert_eq!(tool(&mut s, "inspect_drawing", json!({}))["entityCount"], 2, "drawing edits are allowed");
assert_eq!(tool(&mut s, "render", json!({}))["type"], json!("image"), "a render without `path` writes nothing");
let out = |n: &str| outside.join(n).to_string_lossy().into_owned();
let refused = |s: &mut Server, name: &str, args: Value| {
let r = call(s, 98, "tools/call", json!({"name": name, "arguments": args}));
assert_eq!(r["result"]["isError"], json!(true), "{name} was not refused: {r}");
};
refused(&mut s, "save", json!({"path": out("a.dxf")}));
refused(&mut s, "execute", json!({"command": "saveas", "params": {"path": out("b.dxf")}}));
refused(&mut s, "execute", json!({"command": "wblock", "params": {"path": out("c.dxf")}}));
refused(&mut s, "render", json!({"path": out("d.png")}));
let _ = call(&mut s, 97, "tools/call", json!({"name": "command_line", "arguments": {"text": format!("zoom e save {}", out("e.dxf"))}}));
let _ = call(&mut s, 96, "tools/call", json!({"name": "script", "arguments": {"text": format!("circle 0,0 1\nsave {}\n", out("f.dxf"))}}));
let written: Vec<_> = std::fs::read_dir(&outside).unwrap().filter_map(Result::ok).map(|e| e.file_name()).collect();
assert!(written.is_empty(), "nothing is written outside the roots: {written:?}");
let _ = std::fs::remove_dir_all(&base);
}
-69
View File
@@ -32,75 +32,6 @@ Example client configuration (Claude Code / Claude Desktop):
{ "mcpServers": { "cadcraft": { "command": "cadcraft-cli", "args": ["mcp"] } } }
```
## Confining file access
```sh
cadcraft-cli mcp --automation-read-root /work/project --automation-write-root /work/project/out
```
The two flags (PhotoCraft, VectorCraft and the other Craft apps take the same ones, so one client
configuration works across the suite) keep the agent to the folders you give it:
- Every file a command **reads** must lie inside the **read root or the write root**: `open`,
`recover`, `compare`, `script`, `import`, `insert`, `xattach` and every xref it loads, `new`
templates, `appload` and LISP `load`/`open`, support files (`linetype`, `hatch.patterns`,
`aliasedit`, `reinit`), data links, plot style and plotter configuration files named by a path,
and the shared plotter settings folder.
- Every file a command **writes** must lie inside the **write root**: `save`/`qsave`/`saveas`
(including the temporary file and `.bak` written beside the destination), `export`, `plot`, `publish`,
`pdfbook`, `wblock`, data extraction, table export, plot style and plotter saves, the shared
plotter settings folder, and `render {path}`. The write root itself is refused: a save's
temporary file would sit beside it, outside the root.
- Give the same folder twice for both. A root left out grants none of its *own* access: a read
root allows no writes, while a write root still allows reads inside it (files the agent wrote it
can read back). Without either flag nothing changes.
- A path is made absolute against the server's working directory, then its links are followed: a
file or folder link that leads out of a root is outside it. For a file that doesn't exist yet,
its nearest existing folder's links are followed and the rest must be plain names, so `..` below
a folder that doesn't exist is refused, as is a link that leads nowhere. The result is compared
with the root by whole folder names, exactly: `/work2/x` is not inside `/work`, and on Windows
a folder's own case comes from the file system, so a case-sensitive folder's `Root` is not
`root`. On Windows a UNC path (`\\server\share`, `\\?\UNC\...`, including `\\host@SSL\...`) is
refused before it is opened unless a root is on that same server and share. A device path
(`\\.\...`) is refused unless a root uses the same device, and a verbatim path that isn't a
disk is refused unless a root uses the same prefix. Device names (`CON`, `NUL`, `COM1`,
`LPT¹`…) are refused too.
- A path you write must also stand under the write root: a link outside it pointing in is refused,
because a drawing's `.bak` goes beside the link and a delete removes the link.
- A refused path in a tool other than `command_line` is an ordinary tool error with `isError: true`
that the agent can read and correct, for example `automation path rejected: outside the write root
/work/project/out: /etc/x.png`, `automation path rejected: outside the read root (or the write
root): /etc/x.png`, `automation path rejected: the write root itself cannot be written:
/work/project/out`, `automation path rejected: UNC paths are refused unless a root is on the
same server and share: \\203.0.113.5\s\x.dwg`, or `automation filesystem access is not granted:
write authority is absent: /work/project/out/x.png`.
- A refused path in a `command_line` line is not a tool error: the reply is an ordinary result, with
the refusal in its `error` field (and echoed in `output`) and without `isError`. A client that
drives `command_line` has to read `error`.
- A file a drawing names is held to the roots too: an image or xref saved with a path outside them is
not loaded from there, and the answer doesn't say whether the file exists. As without roots, a file
of the same name beside the host drawing is tried next, so when one is there and inside the roots
it is loaded in its place: check what a reference loaded when it matters.
- A command runs under the roots only if it is classified (`crates/engine/src/file_access/commands.rs`):
one nobody classified is refused, whatever it does. `drawingrecovery` is refused, and SAVEFILEPATH
can't be changed, because both work on the server's autosave folder.
- SHX fonts beside an opened drawing are searched, and each file the search would open there is
checked against the roots first, whatever its name: a font that is a link leading out of the
roots is skipped, and the rest of the folder is still used.
- The server itself still reads the system's fonts, from the system font folders and
`CADCRAFT_SHXPATH`. Their paths come from the server's setup, never from the agent, but a font file
named by a drawing can decide which of them is read.
- The roots must be existing folders; a missing one stops the server with an error. Each flag is
given once (`--flag <dir>` or `--flag=<dir>`).
The flags confine the headless server. `--connect` with them is an error, since the server would
otherwise talk to an app that isn't confined; the app's control channel does not take them yet
(#1585). Without `--connect` the server writes the files itself, so every check happens here.
A path is checked, then opened: another program on the computer that swaps in a link between the two
can still win that race, and a hard link can't be told from a file. Use the operating system's
sandbox as well if other programs can change these folders.
## Tools
| Tool | What it does |