From ab3b5fbe34de0311258305f443aa8bb683e0f2c0 Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 04:52:20 +0100 Subject: [PATCH 1/8] fix: validate AICH recovery proofs before payload reads (RUST-BUG-166) --- crates/emulebb-ed2k/src/ed2k_transfer.rs | 5 + .../emulebb-ed2k/src/ed2k_transfer/salvage.rs | 13 +- .../src/ed2k_transfer/tests/salvage.rs | 248 ++++++++++++++++++ 3 files changed, 261 insertions(+), 5 deletions(-) diff --git a/crates/emulebb-ed2k/src/ed2k_transfer.rs b/crates/emulebb-ed2k/src/ed2k_transfer.rs index 5f1a6c6b7..43b9fb014 100644 --- a/crates/emulebb-ed2k/src/ed2k_transfer.rs +++ b/crates/emulebb-ed2k/src/ed2k_transfer.rs @@ -417,6 +417,9 @@ pub struct Ed2kTransferRuntime { /// When false a corrupted part is fully re-downloaded, never re-hashed /// early against its retained stale bytes. ich_enabled: AtomicBool, + /// Per-runtime test probe, incremented before attempting to open a raw part. + #[cfg(test)] + raw_part_read_attempts: AtomicUsize, /// In-memory client ban store (eMule `CClientList` ban lists), keyed by IP + /// user hash with a 4h `CLIENTBANTIME` TTL. Shared with the inbound listener, /// the download driver, the UDP reask runtime, and core via this runtime's @@ -790,6 +793,8 @@ impl Ed2kTransferRuntime { shared_source_invalidations: Ed2kSharedSourceInvalidationSignal::default(), credit_system_enabled: AtomicBool::new(true), ich_enabled: AtomicBool::new(true), + #[cfg(test)] + raw_part_read_attempts: AtomicUsize::new(0), ban_store, tracked_client_identities, corruption_blackbox: Arc::new(StdMutex::new(HashMap::new())), diff --git a/crates/emulebb-ed2k/src/ed2k_transfer/salvage.rs b/crates/emulebb-ed2k/src/ed2k_transfer/salvage.rs index 1db5ffd96..aff04d5c9 100644 --- a/crates/emulebb-ed2k/src/ed2k_transfer/salvage.rs +++ b/crates/emulebb-ed2k/src/ed2k_transfer/salvage.rs @@ -91,11 +91,6 @@ impl Ed2kTransferRuntime { return Ok(None); } - // Read the current (corrupt) local part bytes. - let part_bytes = self - .read_part_raw_unlocked(file_hash, part_start, part_len) - .await?; - // Verify the recovery data against the trusted master hash and recover // the per-block trusted hashes for this part. let trusted_block_hashes = trusted_part_block_hashes_from_recovery( @@ -104,6 +99,11 @@ impl Ed2kTransferRuntime { u64::from(part_index), recovery_body, )?; + // WHY: reject untrusted recovery proofs before any raw payload read; + // proof validation depends only on geometry and the trusted root. + let part_bytes = self + .read_part_raw_unlocked(file_hash, part_start, part_len) + .await?; let recovery = compute_part_recovery( manifest.file_size, u64::from(part_index), @@ -386,6 +386,9 @@ impl Ed2kTransferRuntime { start: u64, len: u64, ) -> Result> { + #[cfg(test)] + self.raw_part_read_attempts + .fetch_add(1, std::sync::atomic::Ordering::Relaxed); let payload_path = self.transfer_dir(file_hash).join(PAYLOAD_FILE_NAME); let mut file = tokio::fs::OpenOptions::new() .read(true) diff --git a/crates/emulebb-ed2k/src/ed2k_transfer/tests/salvage.rs b/crates/emulebb-ed2k/src/ed2k_transfer/tests/salvage.rs index 101c97953..7556f16c6 100644 --- a/crates/emulebb-ed2k/src/ed2k_transfer/tests/salvage.rs +++ b/crates/emulebb-ed2k/src/ed2k_transfer/tests/salvage.rs @@ -22,6 +22,11 @@ use super::super::{ use crate::paths::unique_test_dir; use emulebb_kad_proto::Ed2kHash; use std::fs; +use std::net::Ipv4Addr; +use std::sync::atomic::Ordering; + +const GOOD_SENDER: Ipv4Addr = Ipv4Addr::new(198, 51, 100, 10); +const BAD_SENDER: Ipv4Addr = Ipv4Addr::new(198, 51, 100, 20); /// Distinct byte for block `idx` so each 180 KB block hashes differently and a /// corruption stays localized to one block. @@ -86,6 +91,230 @@ fn recovery_body_for(data: &[u8], part: u64) -> Vec { sharer.create_part_recovery_data(part).unwrap() } +async fn initialized_salvage_transfer( + tag: &str, +) -> (Ed2kTransferRuntime, String, Vec, Ed2kAichHashset) { + let runtime = Ed2kTransferRuntime::load_or_create(&unique_test_dir(tag)).unwrap(); + let data = build_two_part_payload(); + let (file_hash, md4_parts) = md4_hashset(&data); + let aich = aich_hashset(&data); + let job = new_transfer_job(file_hash, "proof.bin".to_string(), data.len() as u64); + runtime.ensure_job(&job).await.unwrap(); + runtime + .store_md4_hashset(&job.file_hash, md4_parts) + .await + .unwrap(); + runtime + .reconcile_aich_root(&job.file_hash, Some(aich.master_hash)) + .await + .unwrap(); + runtime + .store_aich_hashset(&job.file_hash, aich.clone()) + .await + .unwrap(); + fs::write(runtime.payload_path(&job.file_hash), &data).unwrap(); + (runtime, job.file_hash, data, aich) +} + +#[tokio::test] +async fn rejected_recovery_proofs_never_attempt_raw_payload_reads_or_change_state() { + let (runtime, file_hash, data, aich) = + initialized_salvage_transfer("ed2k-salvage-proof-before-io").await; + runtime.cbb_record_received_data(&file_hash, 0, ED2K_PART_SIZE, GOOD_SENDER, None); + let mut before = runtime.manifest(&file_hash).await.unwrap(); + let mut bitmap = PartBlockBitmap::empty(ED2K_PART_SIZE); + bitmap.set_present(1); + before.pieces[0].apply_block_bitmap(&bitmap); + before.pieces[0].ich_corrupted = true; + { + let _guard = runtime.lock_manifest(&file_hash).await; + runtime.store_manifest_unlocked(&before).await.unwrap(); + } + let attribution = format!("{:?}", runtime.corruption_blackbox.lock().unwrap()); + let mut sharer = AichRecoveryHashSet::new(data.len() as u64); + sharer.build_from_data(&data).unwrap(); + let body16 = sharer.create_part_recovery_data(0).unwrap(); + let body32 = sharer.create_part_recovery_data_force_32bit(0).unwrap(); + let mut cases = Vec::new(); + for (name, body, count_offset, ident_offset, ident_size) in + [("16-bit", &body16, 0, 2, 2), ("32-bit", &body32, 2, 4, 4)] + { + // Remove hash bytes, rather than the ignored 16-bit trailing count. + cases.push(( + format!("{name} truncated"), + body[..body.len() - 5].to_vec(), + "short", + )); + let mut invalid_count = body.clone(); + invalid_count[count_offset..count_offset + 2].copy_from_slice(&1u16.to_le_bytes()); + cases.push(( + format!("{name} count"), + invalid_count, + "hash count mismatch", + )); + for ident in [0u32, 1] { + let mut forbidden = body.clone(); + forbidden[ident_offset..ident_offset + ident_size] + .copy_from_slice(&ident.to_le_bytes()[..ident_size]); + let message = match (ident, ident_size) { + (0, _) => "invalid hash ident (0)", + (_, 2) => "master hash overwrite rejected", + _ => "invalid 32-bit ident", + }; + cases.push(( + format!("{name} forbidden ident {ident}"), + forbidden, + message, + )); + } + if ident_size == 4 { + let mut forbidden = body.clone(); + forbidden[ident_offset..ident_offset + 4].copy_from_slice(&0x40_0001u32.to_le_bytes()); + cases.push(( + format!("{name} oversized ident"), + forbidden, + "invalid 32-bit ident", + )); + } + let mut wrong_root = body.clone(); + wrong_root[ident_offset + ident_size] ^= 0xFF; + cases.push(( + format!("{name} root failure"), + wrong_root, + "hash tree verification failed", + )); + + // Supply the correct two part roots, but no block leaves. Repeating the + // part-0 root preserves the required count and passes root verification; + // the separate lowest-level coverage check must still reject it. + let mut incomplete = body.clone(); + let count = u16::from_le_bytes(body[count_offset..count_offset + 2].try_into().unwrap()); + for index in 0..usize::from(count) { + let offset = ident_offset + index * (ident_size + 20); + let (ident, hash) = if index == 0 { + (2u32, aich.part_hashes[1]) + } else { + (3u32, aich.part_hashes[0]) + }; + incomplete[offset..offset + ident_size] + .copy_from_slice(&ident.to_le_bytes()[..ident_size]); + incomplete[offset + ident_size..offset + ident_size + 20].copy_from_slice(&hash); + } + cases.push(( + format!("{name} incomplete leaves"), + incomplete, + "missing lowest-level block hash", + )); + } + for (name, body, message) in cases { + let error = runtime + .begin_part_salvage(&file_hash, 0, aich.master_hash, &body) + .await + .unwrap_err(); + assert!(error.to_string().contains(message), "{name}: {error:#}"); + assert_eq!( + runtime.raw_part_read_attempts.load(Ordering::Relaxed), + 0, + "{name}" + ); + assert_eq!( + runtime.manifest(&file_hash).await.unwrap(), + before, + "{name}" + ); + assert_eq!( + format!("{:?}", runtime.corruption_blackbox.lock().unwrap()), + attribution, + "{name}" + ); + assert!(!runtime.is_client_banned(Some(GOOD_SENDER), None), "{name}"); + } + for (part, master) in [(0, [0xAB; 20]), (u16::MAX, aich.master_hash)] { + assert!( + runtime + .begin_part_salvage(&file_hash, part, master, &body16) + .await + .unwrap() + .is_none() + ); + assert_eq!(runtime.raw_part_read_attempts.load(Ordering::Relaxed), 0); + assert_eq!(runtime.manifest(&file_hash).await.unwrap(), before); + assert_eq!( + format!("{:?}", runtime.corruption_blackbox.lock().unwrap()), + attribution + ); + } + assert_eq!(fs::read(runtime.payload_path(&file_hash)).unwrap(), data); +} + +#[tokio::test] +async fn recovery_proof_errors_precede_payload_errors_but_valid_proofs_keep_storage_errors() { + let (runtime, file_hash, data, aich) = + initialized_salvage_transfer("ed2k-salvage-proof-storage-errors").await; + let before = runtime.manifest(&file_hash).await.unwrap(); + // Separate from the intact-payload rejection fixtures: deliberately make + // storage unreadable as a complete part to pin the error precedence. + fs::write(runtime.payload_path(&file_hash), []).unwrap(); + let proof_error = runtime + .begin_part_salvage(&file_hash, 0, aich.master_hash, &[0]) + .await + .unwrap_err(); + assert_eq!(proof_error.to_string(), "AICH reader: short u16"); + assert_eq!(runtime.raw_part_read_attempts.load(Ordering::Relaxed), 0); + let storage_error = runtime + .begin_part_salvage( + &file_hash, + 0, + aich.master_hash, + &recovery_body_for(&data, 0), + ) + .await + .unwrap_err(); + assert_eq!( + storage_error + .downcast_ref::() + .unwrap() + .kind(), + std::io::ErrorKind::UnexpectedEof, + ); + assert_eq!(runtime.raw_part_read_attempts.load(Ordering::Relaxed), 1); + assert_eq!(runtime.manifest(&file_hash).await.unwrap(), before); +} + +#[tokio::test] +async fn salvage_repair_still_requires_final_part_md4_verification() { + let (runtime, file_hash, mut data, aich) = + initialized_salvage_transfer("ed2k-salvage-md4-required").await; + let body = recovery_body_for(&data, 0); + data[0] ^= 0xFF; + fs::write(runtime.payload_path(&file_hash), &data).unwrap(); + let outcome = runtime + .begin_part_salvage(&file_hash, 0, aich.master_hash, &body) + .await + .unwrap() + .unwrap(); + assert_eq!(runtime.raw_part_read_attempts.load(Ordering::Relaxed), 1); + assert_eq!(outcome.needed_ranges, vec![(0, ED2K_EMBLOCK_SIZE)]); + let repair = runtime + .write_salvage_block( + &file_hash, + 0, + 0, + ED2K_EMBLOCK_SIZE, + &data[..ED2K_EMBLOCK_SIZE as usize], + ) + .await + .unwrap(); + assert_eq!( + repair, + super::super::PieceWriteOutcome::VerificationFailed { part_index: 0 } + ); + let manifest = runtime.manifest(&file_hash).await.unwrap(); + assert_eq!(manifest.pieces[0].state, Ed2kTransferState::Missing); + assert!(manifest.pieces[0].ich_corrupted); + assert!(!manifest.completed); +} + #[tokio::test] async fn salvage_keeps_good_blocks_and_reverifies_after_one_block() { let root = unique_test_dir("ed2k-salvage-one-block"); @@ -134,11 +363,30 @@ async fn salvage_keeps_good_blocks_and_reverifies_after_one_block() { // Begin salvage with a valid recovery answer for part 0. let body = recovery_body_for(&data, 0); + runtime.cbb_record_received_data(&job.file_hash, 0, ED2K_PART_SIZE, GOOD_SENDER, None); + runtime.cbb_record_received_data( + &job.file_hash, + cb_start as u64, + cb_end as u64, + BAD_SENDER, + None, + ); let outcome = runtime .begin_part_salvage(&job.file_hash, 0, aich.master_hash, &body) .await .unwrap() .expect("salvage should start for a corrupt part with a trusted AICH root"); + assert_eq!(runtime.raw_part_read_attempts.load(Ordering::Relaxed), 1); + assert!(!runtime.is_client_banned(Some(GOOD_SENDER), None)); + assert!(runtime.is_client_banned(Some(BAD_SENDER), None)); + assert_eq!( + runtime.cbb_verified_bytes_for_test(&job.file_hash, GOOD_SENDER), + ED2K_PART_SIZE - ED2K_EMBLOCK_SIZE + ); + assert_eq!( + runtime.cbb_verified_bytes_for_test(&job.file_hash, BAD_SENDER), + 0 + ); // Exactly the one corrupt block is needed; every other block was salvaged. assert_eq!( From 96d41aa2f542d4cf48e31e98a8b38e37a02b6ce8 Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 05:21:43 +0100 Subject: [PATCH 2/8] ci: pin accepted AICH validation providers (RUST-BUG-166) --- .github/workflows/ci.yml | 12 ++++++------ .github/workflows/nightly.yml | 6 +++--- .github/workflows/optional-platforms.yml | 8 ++++---- .github/workflows/release.yml | 14 +++++++------- tools/ci-toolchain.json | 4 ++-- 5 files changed, 22 insertions(+), 22 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 735490f1a..da2c7798a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -17,10 +17,10 @@ permissions: env: CARGO_TERM_COLOR: always RUST_BACKTRACE: 1 - EMULEBB_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_ANDROID_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_BUILD_TESTS_REF: 281ccbcdf9f4c9960c5efda4705df966418b6bb2 - EMULEBB_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e + EMULEBB_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_ANDROID_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b + EMULEBB_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 # Pin the native NAT sources linked by the sys crates. MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b @@ -602,7 +602,7 @@ jobs: with: persist-credentials: false repository: emulebb/emulebb-build-tests - ref: 281ccbcdf9f4c9960c5efda4705df966418b6bb2 + ref: 17438846c1a62fa8228c821071cc79e7cf56145b path: repos/emulebb-build-tests - name: Checkout pinned Rust OpenAPI contract @@ -610,7 +610,7 @@ jobs: with: persist-credentials: false repository: emulebb/emulebb-tooling - ref: f88a8ce608bc75a619aea6909f54a9cdecdddb6e + ref: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 path: repos/emulebb-tooling - name: Download tested Linux daemon diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 34b53c057..921c30b45 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -53,9 +53,9 @@ permissions: contents: read env: - EMULEBB_APK_DIAGNOSTIC_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_APK_DIAGNOSTIC_HARNESS_REF: 281ccbcdf9f4c9960c5efda4705df966418b6bb2 - EMULEBB_APK_DIAGNOSTIC_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e + EMULEBB_APK_DIAGNOSTIC_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_APK_DIAGNOSTIC_HARNESS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b + EMULEBB_APK_DIAGNOSTIC_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 EMULEBB_APK_DIAGNOSTIC_MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c EMULEBB_APK_DIAGNOSTIC_PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b EMULEBB_APK_DIAGNOSTIC_SIGNER_SHA256: 9edc742d7230a714a0149c20eb2afb235b8ad5237166090f10e7ac69e2bb359f diff --git a/.github/workflows/optional-platforms.yml b/.github/workflows/optional-platforms.yml index c0f4e5acd..075352f11 100644 --- a/.github/workflows/optional-platforms.yml +++ b/.github/workflows/optional-platforms.yml @@ -17,10 +17,10 @@ permissions: env: CARGO_TERM_COLOR: always RUST_BACKTRACE: 1 - EMULEBB_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_ANDROID_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_BUILD_TESTS_REF: 281ccbcdf9f4c9960c5efda4705df966418b6bb2 - EMULEBB_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e + EMULEBB_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_ANDROID_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b + EMULEBB_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 # Pin the native NAT sources linked by the sys crates. MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 4ea90b000..6784f19a0 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -51,13 +51,13 @@ permissions: env: RELEASE_PLATFORM_PROFILE: ${{ inputs.platform_profile || 'full' }} RELEASE_CHANNEL: ${{ inputs.channel || (startsWith(github.ref, 'refs/tags/rust-v') && 'beta') || 'candidate' }} - EMULEBB_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_LINUX_PREPARED_IMAGE: ghcr.io/emulebb/emulebb-build-ci/ubuntu-rust@sha256:c94812f3ec606ada847fed87aea7192ba64c1ae3fe11c5cb117f75b6319da62b - EMULEBB_BUILD_TESTS_REF: 281ccbcdf9f4c9960c5efda4705df966418b6bb2 - EMULEBB_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e - EMULEBB_RELEASE_VALIDATOR_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_APK_BUILD_REF: 43515795e85beceeb73b1bbbd77e5ab167ef13b6 - EMULEBB_APK_BUILD_TESTS_REF: 281ccbcdf9f4c9960c5efda4705df966418b6bb2 + EMULEBB_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_LINUX_PREPARED_IMAGE: ghcr.io/emulebb/emulebb-build-ci/ubuntu-rust@sha256:ba73b285184dcf88bd7208e07bae12de90fba707fbc82670cc4c2bf71318ba80 + EMULEBB_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b + EMULEBB_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 + EMULEBB_RELEASE_VALIDATOR_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_APK_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 + EMULEBB_APK_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b EMULEBB_ANDROID_SIGNER_SHA256: 9edc742d7230a714a0149c20eb2afb235b8ad5237166090f10e7ac69e2bb359f MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b diff --git a/tools/ci-toolchain.json b/tools/ci-toolchain.json index 01ca44695..4808f0454 100644 --- a/tools/ci-toolchain.json +++ b/tools/ci-toolchain.json @@ -31,8 +31,8 @@ "inputs": { "emulebb-miniupnp": "4e7a10948004ca2085ac8103e14fc77edb898b4c", "emulebb-libpcpnatpmp": "a6e787f837e507336a8774522c33b54264ef4a4b", - "emulebb-build-tests": "281ccbcdf9f4c9960c5efda4705df966418b6bb2", - "emulebb-tooling": "f88a8ce608bc75a619aea6909f54a9cdecdddb6e" + "emulebb-build-tests": "17438846c1a62fa8228c821071cc79e7cf56145b", + "emulebb-tooling": "dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0" }, "node": "26.13.0", "npm": "11.20.0", From c0eff591e21cd22dd20b7c74e951de0be8e485d3 Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 05:29:18 +0100 Subject: [PATCH 3/8] ci: retain source-owned Tooling provider pin (RUST-BUG-166) --- .github/workflows/ci.yml | 4 ++-- .github/workflows/nightly.yml | 2 +- .github/workflows/optional-platforms.yml | 2 +- .github/workflows/release.yml | 2 +- tools/ci-toolchain.json | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index da2c7798a..5b0fa61d9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -20,7 +20,7 @@ env: EMULEBB_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_ANDROID_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b - EMULEBB_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 + EMULEBB_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e # Pin the native NAT sources linked by the sys crates. MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b @@ -610,7 +610,7 @@ jobs: with: persist-credentials: false repository: emulebb/emulebb-tooling - ref: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 + ref: f88a8ce608bc75a619aea6909f54a9cdecdddb6e path: repos/emulebb-tooling - name: Download tested Linux daemon diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 921c30b45..b42a81d4b 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -55,7 +55,7 @@ permissions: env: EMULEBB_APK_DIAGNOSTIC_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_APK_DIAGNOSTIC_HARNESS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b - EMULEBB_APK_DIAGNOSTIC_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 + EMULEBB_APK_DIAGNOSTIC_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e EMULEBB_APK_DIAGNOSTIC_MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c EMULEBB_APK_DIAGNOSTIC_PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b EMULEBB_APK_DIAGNOSTIC_SIGNER_SHA256: 9edc742d7230a714a0149c20eb2afb235b8ad5237166090f10e7ac69e2bb359f diff --git a/.github/workflows/optional-platforms.yml b/.github/workflows/optional-platforms.yml index 075352f11..a5a887a4f 100644 --- a/.github/workflows/optional-platforms.yml +++ b/.github/workflows/optional-platforms.yml @@ -20,7 +20,7 @@ env: EMULEBB_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_ANDROID_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b - EMULEBB_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 + EMULEBB_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e # Pin the native NAT sources linked by the sys crates. MINIUPNP_REF: 4e7a10948004ca2085ac8103e14fc77edb898b4c PCPNATPMP_REF: a6e787f837e507336a8774522c33b54264ef4a4b diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6784f19a0..03c2f0a81 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -54,7 +54,7 @@ env: EMULEBB_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_LINUX_PREPARED_IMAGE: ghcr.io/emulebb/emulebb-build-ci/ubuntu-rust@sha256:ba73b285184dcf88bd7208e07bae12de90fba707fbc82670cc4c2bf71318ba80 EMULEBB_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b - EMULEBB_TOOLING_REF: dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0 + EMULEBB_TOOLING_REF: f88a8ce608bc75a619aea6909f54a9cdecdddb6e EMULEBB_RELEASE_VALIDATOR_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_APK_BUILD_REF: 177bb6c7118d46268fd9e73d4ae78f5d1516d4e9 EMULEBB_APK_BUILD_TESTS_REF: 17438846c1a62fa8228c821071cc79e7cf56145b diff --git a/tools/ci-toolchain.json b/tools/ci-toolchain.json index 4808f0454..8c5328707 100644 --- a/tools/ci-toolchain.json +++ b/tools/ci-toolchain.json @@ -32,7 +32,7 @@ "emulebb-miniupnp": "4e7a10948004ca2085ac8103e14fc77edb898b4c", "emulebb-libpcpnatpmp": "a6e787f837e507336a8774522c33b54264ef4a4b", "emulebb-build-tests": "17438846c1a62fa8228c821071cc79e7cf56145b", - "emulebb-tooling": "dafbbece059bbc868ed1cf8ab153b7fc7d3fecb0" + "emulebb-tooling": "f88a8ce608bc75a619aea6909f54a9cdecdddb6e" }, "node": "26.13.0", "npm": "11.20.0", From edc8f774f19a006542a10a93ffa0a0ffbdc6b8a0 Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 05:42:48 +0100 Subject: [PATCH 4/8] fix: retain peer credit after failed settlement (RUST-REF-016) --- Cargo.lock | 1 + crates/emulebb-ed2k/Cargo.toml | 1 + .../src/ed2k_transfer/credit_ledger.rs | 113 +++++++++++++++++- 3 files changed, 112 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7f900e0a0..dfd8a40b1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -698,6 +698,7 @@ dependencies = [ "percent-encoding", "rand 0.10.3", "rsa", + "rusqlite", "rustix", "serde", "serde_json", diff --git a/crates/emulebb-ed2k/Cargo.toml b/crates/emulebb-ed2k/Cargo.toml index bfe1269b4..763c209cd 100644 --- a/crates/emulebb-ed2k/Cargo.toml +++ b/crates/emulebb-ed2k/Cargo.toml @@ -76,5 +76,6 @@ libc.workspace = true rustix.workspace = true [dev-dependencies] +rusqlite.workspace = true tempfile.workspace = true tokio = { workspace = true, features = ["test-util"] } diff --git a/crates/emulebb-ed2k/src/ed2k_transfer/credit_ledger.rs b/crates/emulebb-ed2k/src/ed2k_transfer/credit_ledger.rs index 383d7dfcb..162658dcd 100644 --- a/crates/emulebb-ed2k/src/ed2k_transfer/credit_ledger.rs +++ b/crates/emulebb-ed2k/src/ed2k_transfer/credit_ledger.rs @@ -206,9 +206,18 @@ impl Ed2kTransferRuntime { pub(super) fn settle_parked_peer_credit(&self, user_hash: [u8; 16]) -> anyhow::Result<()> { let _gate = self.credit_flush_gate.lock(); let parked = self.parked_credit.lock().peers.remove(&user_hash); - if let Some((uploaded, downloaded)) = parked { - self.metadata - .apply_credit_deltas(&[(hex::encode(user_hash), uploaded, downloaded)], &[])?; + if let Some((uploaded, downloaded)) = parked + && let Err(error) = self + .metadata + .apply_credit_deltas(&[(hex::encode(user_hash), uploaded, downloaded)], &[]) + { + // WHY: a failed settlement must retain its deltas, merging any + // additions parked while SQL ran instead of overwriting them. + self.parked_credit.lock().restore( + HashMap::from([(user_hash, (uploaded, downloaded))]), + HashMap::new(), + ); + return Err(error); } Ok(()) } @@ -245,9 +254,107 @@ impl Ed2kTransferRuntime { #[cfg(test)] mod tests { + use super::*; use crate::ed2k_transfer::Ed2kTransferRuntime; use crate::paths::unique_test_dir; + #[test] + fn failed_peer_settlement_preserves_credit_until_exactly_once_retry_and_reopen() { + let root = unique_test_dir("ed2k-credit-settlement-failure"); + let runtime = Ed2kTransferRuntime::load_or_create(&root).unwrap(); + let user = [0x7Cu8; 16]; + runtime.record_peer_credit_totals(user, 100, 200).unwrap(); + runtime.add_peer_credit_delta(user, 1000, 2000).unwrap(); + let database = rusqlite::Connection::open(root.join("metadata.sqlite")).unwrap(); + let stored_row = || { + database + .query_row( + "SELECT uploaded_bytes, downloaded_bytes, first_seen_at_ms, last_seen_at_ms + FROM peers WHERE user_hash = ?1", + [user.as_slice()], + |row| { + Ok(( + row.get::<_, i64>(0)?, + row.get::<_, i64>(1)?, + row.get::<_, i64>(2)?, + row.get::<_, i64>(3)?, + )) + }, + ) + .unwrap() + }; + let before = stored_row(); + database + .execute_batch( + "CREATE TRIGGER synthetic_peer_settlement_failure BEFORE INSERT ON peers + BEGIN SELECT RAISE(ABORT, 'synthetic peer settlement failure'); END;", + ) + .unwrap(); + + let error = runtime.settle_parked_peer_credit(user).unwrap_err(); + assert!(matches!( + error.downcast_ref::(), + Some(rusqlite::Error::SqliteFailure(_, Some(message))) + if message == "synthetic peer settlement failure" + )); + assert_eq!( + stored_row(), + before, + "failed SQL leaves the durable row unchanged" + ); + assert_eq!(runtime.parked_peer_credit_delta(user), (1000, 2000)); + let visible = runtime.peer_credit_by_hash(user).unwrap().unwrap(); + assert_eq!( + (visible.uploaded_bytes, visible.downloaded_bytes), + (1100, 2200) + ); + + // A later add must survive alongside the failed settlement's deltas. + runtime.add_peer_credit_delta(user, 7, 11).unwrap(); + database + .execute_batch("DROP TRIGGER synthetic_peer_settlement_failure") + .unwrap(); + runtime.settle_parked_peer_credit(user).unwrap(); + assert_eq!(runtime.parked_peer_credit_delta(user), (0, 0)); + assert_eq!((stored_row().0, stored_row().1), (1107, 2211)); + runtime.settle_parked_peer_credit(user).unwrap(); + assert_eq!((stored_row().0, stored_row().1), (1107, 2211)); + drop(database); + drop(runtime); + + let reopened = Ed2kTransferRuntime::load_or_create(&root).unwrap(); + let stored = reopened.peer_credit_by_hash(user).unwrap().unwrap(); + assert_eq!( + (stored.uploaded_bytes, stored.downloaded_bytes), + (1107, 2211) + ); + assert_eq!(reopened.parked_peer_credit_delta(user), (0, 0)); + } + + #[test] + fn failed_settlement_restore_merges_additions_parked_during_sql_with_saturation() { + let runtime = + Ed2kTransferRuntime::load_or_create(&unique_test_dir("ed2k-credit-settlement-merge")) + .unwrap(); + let user = [0x8Du8; 16]; + let other = [0x9Eu8; 16]; + runtime + .add_peer_credit_delta(user, u64::MAX - 3, 20) + .unwrap(); + // Model the controlled interleaving while settlement owns the flush + // gate: SQL has the removed bucket, and producers can still park adds. + let _gate = runtime.credit_flush_gate.lock(); + let removed = runtime.parked_credit.lock().peers.remove(&user).unwrap(); + runtime.add_peer_credit_delta(user, 10, 30).unwrap(); + runtime.add_peer_credit_delta(other, 7, 11).unwrap(); + runtime + .parked_credit + .lock() + .restore(HashMap::from([(user, removed)]), HashMap::new()); + assert_eq!(runtime.parked_peer_credit_delta(user), (u64::MAX, 50)); + assert_eq!(runtime.parked_peer_credit_delta(other), (7, 11)); + } + #[tokio::test] async fn parked_credit_is_read_through_and_flushes_durably() { let root = unique_test_dir("ed2k-credit-ledger"); From cfeb8c498b327fb0bc9fd09bb51518765cbc4aea Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 05:58:07 +0100 Subject: [PATCH 5/8] fix: bound deletion authority marker reads (RUST-BUG-136) --- .../src/ed2k_transfer/metadata.rs | 9 +- .../ed2k_transfer/tests/deliver_runtime.rs | 87 +++++++++++++++++++ 2 files changed, 92 insertions(+), 4 deletions(-) diff --git a/crates/emulebb-ed2k/src/ed2k_transfer/metadata.rs b/crates/emulebb-ed2k/src/ed2k_transfer/metadata.rs index 9399e4ad2..8cd8bc38f 100644 --- a/crates/emulebb-ed2k/src/ed2k_transfer/metadata.rs +++ b/crates/emulebb-ed2k/src/ed2k_transfer/metadata.rs @@ -1795,14 +1795,15 @@ async fn validate_transfer_directory_authority( let matches = tokio::task::spawn_blocking(move || -> Result { use std::io::Read; - let mut marker = match super::ingest::open_regular_file_without_follow(&marker_path) { + let marker = match super::ingest::open_regular_file_without_follow(&marker_path) { Ok(marker) => marker, Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false), Err(error) => return Err(error.into()), }; - let mut contents = Vec::new(); - marker.read_to_end(&mut contents)?; - Ok(contents == marker_id.as_bytes()) + // WHY: Bound corrupt-marker reads while requiring the exact UUID plus no overflow byte. + let mut contents = [0_u8; 17]; + let length = std::io::copy(&mut marker.take(17), &mut contents.as_mut_slice())?; + Ok(length == 16 && contents[..16] == marker_id.as_bytes()[..]) }) .await .context("transfer directory deletion marker validation task failed")??; diff --git a/crates/emulebb-ed2k/src/ed2k_transfer/tests/deliver_runtime.rs b/crates/emulebb-ed2k/src/ed2k_transfer/tests/deliver_runtime.rs index 36742ec06..7e6f69078 100644 --- a/crates/emulebb-ed2k/src/ed2k_transfer/tests/deliver_runtime.rs +++ b/crates/emulebb-ed2k/src/ed2k_transfer/tests/deliver_runtime.rs @@ -1741,6 +1741,93 @@ async fn destructive_delete_recovers_transfer_directory_tombstone() { assert!(restarted.manifest(&hash).await.is_err()); } +#[tokio::test] +async fn destructive_delete_preserves_invalid_markers_across_restart_and_retry() { + for tombstoned in [false, true] { + for (case, length) in [ + ("empty", 0), + ("short", 15), + ("wrong-uuid", 16), + ("overflow", 17), + ("long", 32), + ("huge", 64 * 1024 * 1024), + ] { + let root = unique_test_dir(&format!("ed2k-delete-marker-{case}-{tombstoned}")); + let runtime = Ed2kTransferRuntime::load_or_create(&root).unwrap(); + let payload = b"preserve pending deletion payload"; + let hash = ingest_completed_bytes(&runtime, "Marker.Bounds.bin", payload).await; + let transfer_dir = runtime.transfer_dir(&hash); + let transfer_tombstone = transfer_directory_tombstone_path(&hash, &transfer_dir); + let authority = persist_deletion_intent(&runtime, &hash); + let directory = if tombstoned { + fs::rename(&transfer_dir, &transfer_tombstone).unwrap(); + &transfer_tombstone + } else { + &transfer_dir + }; + let payload_path = directory.join(runtime.payload_path(&hash).file_name().unwrap()); + let marker_path = + transfer_directory_authority_marker_path(directory, authority.marker_id); + let mut contents = *authority.marker_id.as_bytes(); + if case == "wrong-uuid" { + contents[0] ^= 1; + } + fs::write(&marker_path, contents).unwrap(); + fs::OpenOptions::new() + .write(true) + .open(&marker_path) + .unwrap() + .set_len(length) + .unwrap(); + drop(runtime); + + let restarted = Ed2kTransferRuntime::load_or_create(&root).unwrap(); + for _ in 0..2 { + let report = restarted + .recover_pending_transfer_deletions() + .await + .unwrap(); + assert_eq!(report.recovered, 0, "{case}, tombstoned={tombstoned}"); + assert_eq!(report.failures.len(), 1); + assert!(report.failures[0].contains("authority marker changed")); + assert_eq!(fs::read(&payload_path).unwrap(), payload); + assert_eq!(fs::metadata(&marker_path).unwrap().len(), length); + assert_eq!( + super::super::ingest::native_directory_identity(directory), + Some(authority.identity) + ); + assert_eq!(transfer_dir.exists(), !tombstoned); + assert_eq!(transfer_tombstone.exists(), tombstoned); + assert_eq!( + restarted + .metadata + .pending_transfer_deletion_hashes() + .unwrap(), + vec![hash.clone()] + ); + } + + fs::write(&marker_path, authority.marker_id.as_bytes()).unwrap(); + assert_complete_deletion_recovery( + restarted + .recover_pending_transfer_deletions() + .await + .unwrap(), + 1, + ); + assert!(!transfer_dir.exists()); + assert!(!transfer_tombstone.exists()); + assert!( + restarted + .metadata + .pending_transfer_deletion_hashes() + .unwrap() + .is_empty() + ); + } + } +} + #[tokio::test] async fn destructive_delete_preserves_tombstone_without_authority_marker() { let root = unique_test_dir("ed2k-delete-transfer-dir-tombstone-marker-missing"); From 355eab16868b9e40ccae4c6ecbfb0e158eb23e65 Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 07:04:00 +0100 Subject: [PATCH 6/8] fix(webui): reveal focused table actions (RUST-FEAT-056) --- webui/src/components.tsx | 8 +++++++- webui/tests/e2e/mobile-appearance.spec.ts | 2 +- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/webui/src/components.tsx b/webui/src/components.tsx index a32889cb7..fa4e0de43 100644 --- a/webui/src/components.tsx +++ b/webui/src/components.tsx @@ -25,7 +25,13 @@ export function TableScroll(props: { children: ComponentChildren; label?: string
+ aria-describedby={overflow ? hintId : undefined} onFocusCapture={(event) => { + const target = event.target as Element; + // WHY: mobile WebKit can leave a focused row action clipped after keyboard scrolling. + if (overflow && target !== event.currentTarget) { + target.scrollIntoView({ block: "nearest", inline: "nearest", behavior: "instant" }); + } + }}> {props.children}
diff --git a/webui/tests/e2e/mobile-appearance.spec.ts b/webui/tests/e2e/mobile-appearance.spec.ts index ff3dc24b1..c9f063f43 100644 --- a/webui/tests/e2e/mobile-appearance.spec.ts +++ b/webui/tests/e2e/mobile-appearance.spec.ts @@ -233,7 +233,7 @@ for (const width of [320, 390]) { await page.keyboard.press("ArrowRight"); await expect.poll(() => scroll.evaluate((element) => element.scrollLeft)).toBeGreaterThan(0); const action = table.getByTitle("Remove", { exact: true }).first(); - await action.focus(); + await page.keyboard.press("Tab"); await expect(action).toBeFocused(); await expect.poll(() => action.evaluate((element) => { const button = element.getBoundingClientRect(); From 67f9b688dc887250535435e0a4ea11c63740c19c Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 07:18:58 +0100 Subject: [PATCH 7/8] test: hard-link isolated profile executable (RUST-CI-043) --- .../emulebb-daemon/tests/profile_ownership.rs | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/crates/emulebb-daemon/tests/profile_ownership.rs b/crates/emulebb-daemon/tests/profile_ownership.rs index c3429257b..25bfd23f4 100644 --- a/crates/emulebb-daemon/tests/profile_ownership.rs +++ b/crates/emulebb-daemon/tests/profile_ownership.rs @@ -333,11 +333,13 @@ fn executable_default_ignores_shell_cwd_and_explicit_profiles_resolve_from_it() for directory in [&executable_dir, &other_cwd, &unused_home] { fs::create_dir(directory).unwrap(); } - // WHY: invoking the original unit-test executable with no profile would - // write beside a shared Cargo artifact. Copy the fixture into owned output. + // WHY: keep default-profile writes in owned output without opening the + // executable for writing (transient inherited writers can cause ETXTBSY). + // Both paths share the Cargo target filesystem; a hard link keeps the owned launch path. let current = env::current_exe().unwrap(); - let copied = executable_dir.join(current.file_name().unwrap()); - fs::copy(current, &copied).unwrap(); + let isolated_executable = executable_dir.join(current.file_name().unwrap()); + fs::hard_link(¤t, &isolated_executable) + .expect("hard-link profile fixture within the Cargo target filesystem"); fs::write(other_cwd.join("not-a-directory"), b"synthetic blocked path").unwrap(); for (mode, cwd, expected) in [ @@ -362,7 +364,7 @@ fn executable_default_ignores_shell_cwd_and_explicit_profiles_resolve_from_it() other_cwd.join("not-a-directory"), ), ] { - let mut command = Command::new(&copied); + let mut command = Command::new(&isolated_executable); command .current_dir(cwd) .env("HOME", &unused_home) @@ -374,4 +376,11 @@ fn executable_default_ignores_shell_cwd_and_explicit_profiles_resolve_from_it() } assert!(!other_cwd.join("emulebb-rust-settings.toml").exists()); assert!(fs::read_dir(unused_home).unwrap().next().is_none()); + temporary + .close() + .expect("remove owned profile executable fixture"); + assert!( + current.is_file(), + "fixture cleanup removed the original test executable" + ); } From c6b9ceff0590b222fe5c5cc23df8622c229809d1 Mon Sep 17 00:00:00 2001 From: Threepwood-7 Date: Sun, 15 Nov 2026 08:01:20 +0100 Subject: [PATCH 8/8] test: stage profile executable in an isolated child (RUST-CI-043) --- .../emulebb-daemon/tests/profile_ownership.rs | 21 ++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/crates/emulebb-daemon/tests/profile_ownership.rs b/crates/emulebb-daemon/tests/profile_ownership.rs index 25bfd23f4..0eff2911b 100644 --- a/crates/emulebb-daemon/tests/profile_ownership.rs +++ b/crates/emulebb-daemon/tests/profile_ownership.rs @@ -260,6 +260,11 @@ fn profile_clones_and_metadata_handles_share_one_logical_lease() { fn profile_ownership_child() { let profile_path = PathBuf::from(env::var_os(CHILD_PROFILE).unwrap()); let mode = env::var(CHILD_MODE).unwrap(); + if mode == "prepare-executable" { + let current = env::current_exe().unwrap(); + fs::copy(¤t, profile_path.join(current.file_name().unwrap())).unwrap(); + return; + } let result = match mode.as_str() { "executable-default" => DaemonProfile::load(None), "explicit-dot" => DaemonProfile::load(Some(PathBuf::from("."))), @@ -333,13 +338,19 @@ fn executable_default_ignores_shell_cwd_and_explicit_profiles_resolve_from_it() for directory in [&executable_dir, &other_cwd, &unused_home] { fs::create_dir(directory).unwrap(); } - // WHY: keep default-profile writes in owned output without opening the - // executable for writing (transient inherited writers can cause ETXTBSY). - // Both paths share the Cargo target filesystem; a hard link keeps the owned launch path. + // WHY: tmpfs profile scratch can be on a different mount from Cargo artifacts. + // Stage in a child that spawns no descendants and wait for its exit so parallel + // parent launches cannot inherit a writer and cause ETXTBSY. let current = env::current_exe().unwrap(); let isolated_executable = executable_dir.join(current.file_name().unwrap()); - fs::hard_link(¤t, &isolated_executable) - .expect("hard-link profile fixture within the Cargo target filesystem"); + { + let mut preparation = OwnedChild::start( + &executable_dir, + "prepare-executable", + &temporary.path().join("ready"), + ); + preparation.finish(); + } fs::write(other_cwd.join("not-a-directory"), b"synthetic blocked path").unwrap(); for (mode, cwd, expected) in [