feat(core): add versioned fake-session C ABI
This commit is contained in:
sechmachine
@@ -0,0 +1,692 @@
|
||||
#![allow(
|
||||
unsafe_code,
|
||||
clippy::borrow_as_ptr,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::items_after_statements
|
||||
)]
|
||||
|
||||
use std::ffi::c_void;
|
||||
use std::mem::{offset_of, size_of};
|
||||
use std::ptr;
|
||||
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Barrier, Condvar, Mutex};
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const ABI_V1: u32 = 1;
|
||||
const OK: u32 = 0;
|
||||
const INVALID_ARGUMENT: u32 = 1;
|
||||
const INVALID_STATE: u32 = 2;
|
||||
const UNSUPPORTED_ABI: u32 = 3;
|
||||
const QUEUE_FULL: u32 = 9;
|
||||
const CANCELLED: u32 = 10;
|
||||
const REENTRANT: u32 = 11;
|
||||
const BUSY: u32 = 12;
|
||||
|
||||
const STATE_CONNECTING: u32 = 1;
|
||||
const STATE_CONNECTED: u32 = 2;
|
||||
const STATE_CANCELLED: u32 = 3;
|
||||
const INPUT_KEYBOARD: u32 = 1;
|
||||
|
||||
#[repr(C)]
|
||||
struct Core {
|
||||
_private: [u8; 0],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy)]
|
||||
struct BytesView {
|
||||
data: *const u8,
|
||||
length: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct StateEvent {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
state: u32,
|
||||
reason: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct ErrorEvent {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
code: u32,
|
||||
retryable: u32,
|
||||
phase: u32,
|
||||
reserved: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct StatsEvent {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
dropped_callbacks: u64,
|
||||
dropped_media_units: u64,
|
||||
dropped_input_events: u64,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct MediaEvent {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
channel: u32,
|
||||
sequence: u32,
|
||||
timestamp_ms: u64,
|
||||
encoded_unit: BytesView,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct ControlEvent {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
kind: u32,
|
||||
reserved: u32,
|
||||
payload: BytesView,
|
||||
}
|
||||
|
||||
type SignFn = unsafe extern "C" fn(*mut c_void, BytesView, *mut u8) -> u32;
|
||||
type StateFn = unsafe extern "C" fn(*mut c_void, *const StateEvent);
|
||||
type ErrorFn = unsafe extern "C" fn(*mut c_void, *const ErrorEvent);
|
||||
type StatsFn = unsafe extern "C" fn(*mut c_void, *const StatsEvent);
|
||||
type MediaFn = unsafe extern "C" fn(*mut c_void, *const MediaEvent);
|
||||
type ControlFn = unsafe extern "C" fn(*mut c_void, *const ControlEvent);
|
||||
|
||||
#[repr(C)]
|
||||
struct Config {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
context: *mut c_void,
|
||||
sign_admission: Option<SignFn>,
|
||||
sign_tls_ed25519: Option<SignFn>,
|
||||
on_state: Option<StateFn>,
|
||||
on_error: Option<ErrorFn>,
|
||||
on_stats: Option<StatsFn>,
|
||||
on_media: Option<MediaFn>,
|
||||
on_control: Option<ControlFn>,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct ConnectRequest {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
manifest_json: BytesView,
|
||||
tunnel_credential_json: BytesView,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct InputEvent {
|
||||
struct_size: u32,
|
||||
abi_version: u32,
|
||||
kind: u32,
|
||||
flags: u32,
|
||||
values: [i32; 12],
|
||||
}
|
||||
|
||||
unsafe extern "C" {
|
||||
fn verse_core_abi_version() -> u32;
|
||||
fn verse_core_create_v1(config: *const Config, out_core: *mut *mut Core) -> u32;
|
||||
fn verse_core_connect_v1(core: *mut Core, request: *const ConnectRequest) -> u32;
|
||||
fn verse_core_send_input_v1(core: *mut Core, event: *const InputEvent) -> u32;
|
||||
fn verse_core_request_idr_v1(core: *mut Core) -> u32;
|
||||
fn verse_core_cancel_v1(core: *mut Core) -> u32;
|
||||
fn verse_core_destroy_v1(core: *mut Core, timeout_ms: u32) -> u32;
|
||||
}
|
||||
|
||||
const MANIFEST: &[u8] = br#"{
|
||||
"version":"1","purpose":"launch","session_id":"session","reconnect_sequence":0,
|
||||
"gateway":{"id":"gateway","addresses":["gateway.test:443"],"public_identity":"gateway.test"},
|
||||
"tunnel":{"versions":["verse-gateway-v1/1"],"features":["control.v1","input.absolute.v1","input.scroll.v1"]},
|
||||
"profile":{"id":"standard","bounds":{"minimum_kbps":1000,"target_kbps":5000,"maximum_kbps":10000},"display_mode":{"resolution_width":1920,"resolution_height":1080,"fps":60}},
|
||||
"grant":{"opaque_value":"ggggggggggggggggggggggggggggggggggggggggggg","expires_at":"2099-01-01T00:00:00Z","audience":"audience"},
|
||||
"correlation_id":"correlation"
|
||||
}"#;
|
||||
const CREDENTIAL: &[u8] = br#"{"client_device_id":"device","device_key_id":"key","certificate_chain_pem":"-----BEGIN CERTIFICATE-----\nAQID\n-----END CERTIFICATE-----","trust_bundle_pem":"-----BEGIN CERTIFICATE-----\nAQID\n-----END CERTIFICATE-----","expires_at":"2099-01-01T00:00:00Z"}"#;
|
||||
|
||||
struct Context {
|
||||
core: AtomicUsize,
|
||||
admission_calls: AtomicUsize,
|
||||
tls_calls: AtomicUsize,
|
||||
admission_input: Mutex<Vec<u8>>,
|
||||
tls_input: Mutex<Vec<u8>>,
|
||||
states: Mutex<Vec<u32>>,
|
||||
wake: Condvar,
|
||||
reentry_cancel: AtomicU32,
|
||||
reentry_send: AtomicU32,
|
||||
reentry_destroy: AtomicU32,
|
||||
block_callbacks: AtomicBool,
|
||||
release_callbacks: AtomicBool,
|
||||
callback_active: AtomicUsize,
|
||||
callback_max: AtomicUsize,
|
||||
cancel_on_connecting: AtomicBool,
|
||||
}
|
||||
|
||||
impl Default for Context {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
core: AtomicUsize::new(0),
|
||||
admission_calls: AtomicUsize::new(0),
|
||||
tls_calls: AtomicUsize::new(0),
|
||||
admission_input: Mutex::new(Vec::new()),
|
||||
tls_input: Mutex::new(Vec::new()),
|
||||
states: Mutex::new(Vec::new()),
|
||||
wake: Condvar::new(),
|
||||
reentry_cancel: AtomicU32::new(u32::MAX),
|
||||
reentry_send: AtomicU32::new(u32::MAX),
|
||||
reentry_destroy: AtomicU32::new(u32::MAX),
|
||||
block_callbacks: AtomicBool::new(false),
|
||||
release_callbacks: AtomicBool::new(false),
|
||||
callback_active: AtomicUsize::new(0),
|
||||
callback_max: AtomicUsize::new(0),
|
||||
cancel_on_connecting: AtomicBool::new(false),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn context<'a>(raw: *mut c_void) -> &'a Context {
|
||||
// Test invariant: every callback receives the live Box<Context> supplied at create.
|
||||
unsafe { &*raw.cast::<Context>() }
|
||||
}
|
||||
|
||||
unsafe extern "C" fn sign_admission(raw: *mut c_void, input: BytesView, output: *mut u8) -> u32 {
|
||||
// Test invariant: ABI promises input is readable for input.length during this callback.
|
||||
let bytes = unsafe { std::slice::from_raw_parts(input.data, input.length) };
|
||||
let ctx = unsafe { context(raw) };
|
||||
ctx.admission_calls.fetch_add(1, Ordering::SeqCst);
|
||||
*ctx.admission_input.lock().expect("admission lock") = bytes.to_vec();
|
||||
// Test invariant: ABI promises a writable 64-byte Rust-owned signature buffer.
|
||||
unsafe { ptr::write_bytes(output, 0xA5, 64) };
|
||||
OK
|
||||
}
|
||||
|
||||
unsafe extern "C" fn sign_tls(raw: *mut c_void, input: BytesView, output: *mut u8) -> u32 {
|
||||
// Test invariant: ABI promises input is readable for input.length during this callback.
|
||||
let bytes = unsafe { std::slice::from_raw_parts(input.data, input.length) };
|
||||
let ctx = unsafe { context(raw) };
|
||||
ctx.tls_calls.fetch_add(1, Ordering::SeqCst);
|
||||
*ctx.tls_input.lock().expect("tls lock") = bytes.to_vec();
|
||||
// Test invariant: ABI promises a writable 64-byte Rust-owned signature buffer.
|
||||
unsafe { ptr::write_bytes(output, 0x5A, 64) };
|
||||
OK
|
||||
}
|
||||
|
||||
unsafe extern "C" fn on_state(raw: *mut c_void, event: *const StateEvent) {
|
||||
let ctx = unsafe { context(raw) };
|
||||
let active = ctx.callback_active.fetch_add(1, Ordering::SeqCst) + 1;
|
||||
ctx.callback_max.fetch_max(active, Ordering::SeqCst);
|
||||
// Test invariant: ABI promises a readable state record for the callback duration.
|
||||
let state = unsafe { (*event).state };
|
||||
ctx.states.lock().expect("states lock").push(state);
|
||||
ctx.wake.notify_all();
|
||||
|
||||
if state == STATE_CONNECTING && ctx.cancel_on_connecting.load(Ordering::SeqCst) {
|
||||
let core = ctx.core.load(Ordering::SeqCst) as *mut Core;
|
||||
ctx.reentry_cancel
|
||||
.store(unsafe { verse_core_cancel_v1(core) }, Ordering::SeqCst);
|
||||
}
|
||||
|
||||
if ctx.block_callbacks.load(Ordering::SeqCst) && !ctx.release_callbacks.load(Ordering::SeqCst) {
|
||||
let mut states = ctx.states.lock().expect("states lock");
|
||||
while !ctx.release_callbacks.load(Ordering::SeqCst) {
|
||||
states = ctx.wake.wait(states).expect("callback wait");
|
||||
}
|
||||
}
|
||||
|
||||
if state == STATE_CONNECTED && ctx.reentry_cancel.load(Ordering::SeqCst) == u32::MAX {
|
||||
let core = ctx.core.load(Ordering::SeqCst) as *mut Core;
|
||||
// Test invariant: the stored handle is live until this callback and its destroy complete.
|
||||
ctx.reentry_cancel
|
||||
.store(unsafe { verse_core_cancel_v1(core) }, Ordering::SeqCst);
|
||||
let event = keyboard_event();
|
||||
// Test invariant: event and handle remain valid for the synchronous call.
|
||||
ctx.reentry_send.store(
|
||||
unsafe { verse_core_send_input_v1(core, &event) },
|
||||
Ordering::SeqCst,
|
||||
);
|
||||
// Test invariant: the callback intentionally probes the documented reentry rejection.
|
||||
ctx.reentry_destroy
|
||||
.store(unsafe { verse_core_destroy_v1(core, 1) }, Ordering::SeqCst);
|
||||
}
|
||||
ctx.callback_active.fetch_sub(1, Ordering::SeqCst);
|
||||
}
|
||||
|
||||
unsafe extern "C" fn sign_admission_reenters(
|
||||
raw: *mut c_void,
|
||||
input: BytesView,
|
||||
output: *mut u8,
|
||||
) -> u32 {
|
||||
let ctx = unsafe { context(raw) };
|
||||
ctx.reentry_cancel.store(
|
||||
unsafe { verse_core_cancel_v1(ctx.core.load(Ordering::SeqCst) as *mut Core) },
|
||||
Ordering::SeqCst,
|
||||
);
|
||||
unsafe { sign_admission(raw, input, output) }
|
||||
}
|
||||
|
||||
unsafe extern "C" fn sign_admission_waits_for_cancel(
|
||||
raw: *mut c_void,
|
||||
input: BytesView,
|
||||
output: *mut u8,
|
||||
) -> u32 {
|
||||
let ctx = unsafe { context(raw) };
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
while ctx.reentry_cancel.load(Ordering::SeqCst) == u32::MAX {
|
||||
assert!(
|
||||
Instant::now() < deadline,
|
||||
"connecting callback did not cancel"
|
||||
);
|
||||
thread::yield_now();
|
||||
}
|
||||
unsafe { sign_admission(raw, input, output) }
|
||||
}
|
||||
|
||||
fn config(ctx: &mut Context) -> Config {
|
||||
Config {
|
||||
struct_size: size_of::<Config>() as u32,
|
||||
abi_version: ABI_V1,
|
||||
context: ptr::from_mut(ctx).cast(),
|
||||
sign_admission: Some(sign_admission),
|
||||
sign_tls_ed25519: Some(sign_tls),
|
||||
on_state: Some(on_state),
|
||||
on_error: None,
|
||||
on_stats: None,
|
||||
on_media: None,
|
||||
on_control: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn request(manifest: &[u8], credential: &[u8]) -> ConnectRequest {
|
||||
ConnectRequest {
|
||||
struct_size: size_of::<ConnectRequest>() as u32,
|
||||
abi_version: ABI_V1,
|
||||
manifest_json: BytesView {
|
||||
data: manifest.as_ptr(),
|
||||
length: manifest.len(),
|
||||
},
|
||||
tunnel_credential_json: BytesView {
|
||||
data: credential.as_ptr(),
|
||||
length: credential.len(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn keyboard_event() -> InputEvent {
|
||||
let mut values = [0; 12];
|
||||
values[0] = 1;
|
||||
values[2] = 30;
|
||||
InputEvent {
|
||||
struct_size: size_of::<InputEvent>() as u32,
|
||||
abi_version: ABI_V1,
|
||||
kind: INPUT_KEYBOARD,
|
||||
flags: 0,
|
||||
values,
|
||||
}
|
||||
}
|
||||
|
||||
fn create(ctx: &mut Context) -> *mut Core {
|
||||
let mut core = ptr::null_mut();
|
||||
let config = config(ctx);
|
||||
// Test invariant: config/out pointers remain valid for the synchronous create call.
|
||||
assert_eq!(unsafe { verse_core_create_v1(&config, &mut core) }, OK);
|
||||
assert!(!core.is_null());
|
||||
ctx.core.store(core as usize, Ordering::SeqCst);
|
||||
core
|
||||
}
|
||||
|
||||
fn connect(core: *mut Core, manifest: &[u8], credential: &[u8]) -> u32 {
|
||||
let request = request(manifest, credential);
|
||||
// Test invariant: request and backing byte slices remain valid for the synchronous call.
|
||||
unsafe { verse_core_connect_v1(core, &request) }
|
||||
}
|
||||
|
||||
fn wait_for(ctx: &Context, predicate: impl Fn(&[u32]) -> bool) {
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
let mut states = ctx.states.lock().expect("states lock");
|
||||
while !predicate(&states) {
|
||||
let remaining = deadline.saturating_duration_since(Instant::now());
|
||||
assert!(
|
||||
!remaining.is_zero(),
|
||||
"callback deadline exceeded: {states:?}"
|
||||
);
|
||||
(states, _) = ctx
|
||||
.wake
|
||||
.wait_timeout(states, remaining)
|
||||
.expect("callback wait");
|
||||
}
|
||||
}
|
||||
|
||||
fn destroy(core: *mut Core) -> u32 {
|
||||
// Test invariant: caller retains the handle until destroy reports success.
|
||||
unsafe { verse_core_destroy_v1(core, 2_000) }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arm64_c_layout_is_exact_and_version_is_fixed() {
|
||||
assert_eq!(versevdi_core::session::INPUT_QUEUE_CAPACITY, 64);
|
||||
assert_eq!(size_of::<BytesView>(), 16);
|
||||
assert_eq!(size_of::<Config>(), 72);
|
||||
assert_eq!(offset_of!(Config, sign_admission), 16);
|
||||
assert_eq!(size_of::<ConnectRequest>(), 40);
|
||||
assert_eq!(offset_of!(ConnectRequest, manifest_json), 8);
|
||||
assert_eq!(size_of::<InputEvent>(), 64);
|
||||
assert_eq!(size_of::<StateEvent>(), 16);
|
||||
assert_eq!(size_of::<ErrorEvent>(), 24);
|
||||
assert_eq!(size_of::<StatsEvent>(), 32);
|
||||
assert_eq!(size_of::<MediaEvent>(), 40);
|
||||
assert_eq!(size_of::<ControlEvent>(), 32);
|
||||
// Test invariant: no pointer arguments are involved.
|
||||
assert_eq!(unsafe { verse_core_abi_version() }, ABI_V1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_validates_prefix_callbacks_output_and_trailing_bytes() {
|
||||
let mut ctx = Context::default();
|
||||
let mut core = ptr::dangling_mut::<Core>();
|
||||
let mut cfg = config(&mut ctx);
|
||||
|
||||
cfg.struct_size = 7;
|
||||
// Test invariant: config/out are readable/writable for this call.
|
||||
assert_eq!(
|
||||
unsafe { verse_core_create_v1(&cfg, &mut core) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
assert!(core.is_null());
|
||||
|
||||
cfg = config(&mut ctx);
|
||||
cfg.abi_version = 2;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_create_v1(&cfg, &mut core) },
|
||||
UNSUPPORTED_ABI
|
||||
);
|
||||
assert!(core.is_null());
|
||||
|
||||
cfg = config(&mut ctx);
|
||||
cfg.sign_tls_ed25519 = None;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_create_v1(&cfg, &mut core) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
assert!(core.is_null());
|
||||
|
||||
#[repr(C)]
|
||||
struct Extended {
|
||||
base: Config,
|
||||
ignored: [u8; 32],
|
||||
}
|
||||
let extended = Extended {
|
||||
base: config(&mut ctx),
|
||||
ignored: [0xEE; 32],
|
||||
};
|
||||
let mut extended = extended;
|
||||
extended.base.struct_size = size_of::<Extended>() as u32;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_create_v1(&extended.base, &mut core) },
|
||||
OK
|
||||
);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connect_copies_inputs_and_calls_purpose_specific_signers_once() {
|
||||
let mut ctx = Context::default();
|
||||
let core = create(&mut ctx);
|
||||
let mut manifest = MANIFEST.to_vec();
|
||||
let mut credential = CREDENTIAL.to_vec();
|
||||
assert_eq!(connect(core, &manifest, &credential), OK);
|
||||
manifest.fill(b'x');
|
||||
credential.fill(b'y');
|
||||
|
||||
assert_eq!(ctx.admission_calls.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(ctx.tls_calls.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(&*ctx.admission_input.lock().expect("admission"), MANIFEST);
|
||||
assert_eq!(&*ctx.tls_input.lock().expect("tls"), CREDENTIAL);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tables_and_slices_reject_short_unsupported_null_and_oversized_inputs() {
|
||||
let mut ctx = Context::default();
|
||||
ctx.reentry_cancel.store(OK, Ordering::SeqCst);
|
||||
let core = create(&mut ctx);
|
||||
let mut req = request(MANIFEST, CREDENTIAL);
|
||||
|
||||
req.struct_size = 7;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_connect_v1(core, &req) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
req.struct_size = size_of::<ConnectRequest>() as u32;
|
||||
req.abi_version = 2;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_connect_v1(core, &req) },
|
||||
UNSUPPORTED_ABI
|
||||
);
|
||||
req.abi_version = ABI_V1;
|
||||
req.manifest_json = BytesView {
|
||||
data: ptr::null(),
|
||||
length: 1,
|
||||
};
|
||||
assert_eq!(
|
||||
unsafe { verse_core_connect_v1(core, &req) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
req.manifest_json = BytesView {
|
||||
data: ptr::null(),
|
||||
length: 0,
|
||||
};
|
||||
assert_eq!(
|
||||
unsafe { verse_core_connect_v1(core, &req) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
req.manifest_json.length = 1_048_577;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_connect_v1(core, &req) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
|
||||
let mut input = keyboard_event();
|
||||
input.struct_size = 7;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_send_input_v1(core, &input) },
|
||||
INVALID_ARGUMENT
|
||||
);
|
||||
input.struct_size = size_of::<InputEvent>() as u32;
|
||||
input.abi_version = 2;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_send_input_v1(core, &input) },
|
||||
UNSUPPORTED_ABI
|
||||
);
|
||||
|
||||
#[repr(C)]
|
||||
struct ExtendedRequest {
|
||||
base: ConnectRequest,
|
||||
ignored: [u8; 24],
|
||||
}
|
||||
let mut trailing_request = ExtendedRequest {
|
||||
base: request(MANIFEST, CREDENTIAL),
|
||||
ignored: [0xEE; 24],
|
||||
};
|
||||
trailing_request.base.struct_size = size_of::<ExtendedRequest>() as u32;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_connect_v1(core, &trailing_request.base) },
|
||||
OK
|
||||
);
|
||||
|
||||
#[repr(C)]
|
||||
struct ExtendedInput {
|
||||
base: InputEvent,
|
||||
ignored: [u8; 24],
|
||||
}
|
||||
let mut trailing_input = ExtendedInput {
|
||||
base: keyboard_event(),
|
||||
ignored: [0xEE; 24],
|
||||
};
|
||||
trailing_input.base.struct_size = size_of::<ExtendedInput>() as u32;
|
||||
assert_eq!(
|
||||
unsafe { verse_core_send_input_v1(core, &trailing_input.base) },
|
||||
OK
|
||||
);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn callback_order_is_serial_and_only_cancel_is_reentrant() {
|
||||
let mut ctx = Context::default();
|
||||
let core = create(&mut ctx);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), OK);
|
||||
wait_for(&ctx, |states| states.contains(&STATE_CANCELLED));
|
||||
|
||||
assert_eq!(
|
||||
ctx.states.lock().expect("states").as_slice(),
|
||||
[STATE_CONNECTING, STATE_CONNECTED, STATE_CANCELLED]
|
||||
);
|
||||
assert_eq!(ctx.reentry_cancel.load(Ordering::SeqCst), OK);
|
||||
assert_eq!(ctx.reentry_send.load(Ordering::SeqCst), REENTRANT);
|
||||
assert_eq!(ctx.reentry_destroy.load(Ordering::SeqCst), REENTRANT);
|
||||
assert_eq!(ctx.callback_max.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signer_callbacks_cannot_reenter_even_cancel() {
|
||||
let mut ctx = Context::default();
|
||||
let mut cfg = config(&mut ctx);
|
||||
cfg.sign_admission = Some(sign_admission_reenters);
|
||||
let mut core = ptr::null_mut();
|
||||
assert_eq!(unsafe { verse_core_create_v1(&cfg, &mut core) }, OK);
|
||||
ctx.core.store(core as usize, Ordering::SeqCst);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), OK);
|
||||
assert_eq!(ctx.reentry_cancel.load(Ordering::SeqCst), REENTRANT);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cancel_during_connect_preserves_state_order_and_stops_before_tls_signing() {
|
||||
let mut ctx = Context::default();
|
||||
ctx.cancel_on_connecting.store(true, Ordering::SeqCst);
|
||||
let mut cfg = config(&mut ctx);
|
||||
cfg.sign_admission = Some(sign_admission_waits_for_cancel);
|
||||
let mut core = ptr::null_mut();
|
||||
assert_eq!(unsafe { verse_core_create_v1(&cfg, &mut core) }, OK);
|
||||
ctx.core.store(core as usize, Ordering::SeqCst);
|
||||
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), CANCELLED);
|
||||
wait_for(&ctx, |states| states.contains(&STATE_CANCELLED));
|
||||
assert_eq!(
|
||||
ctx.states.lock().expect("states").as_slice(),
|
||||
[STATE_CONNECTING, STATE_CANCELLED]
|
||||
);
|
||||
assert_eq!(ctx.tls_calls.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_input_is_nonblocking_bounded_and_cancel_is_idempotent() {
|
||||
let mut ctx = Context::default();
|
||||
ctx.reentry_cancel.store(OK, Ordering::SeqCst);
|
||||
let core = create(&mut ctx);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), OK);
|
||||
let event = keyboard_event();
|
||||
for _ in 0..64 {
|
||||
assert_eq!(unsafe { verse_core_send_input_v1(core, &event) }, OK);
|
||||
}
|
||||
assert_eq!(
|
||||
unsafe { verse_core_send_input_v1(core, &event) },
|
||||
QUEUE_FULL
|
||||
);
|
||||
assert_eq!(unsafe { verse_core_request_idr_v1(core) }, OK);
|
||||
assert_eq!(unsafe { verse_core_cancel_v1(core) }, OK);
|
||||
assert_eq!(unsafe { verse_core_cancel_v1(core) }, OK);
|
||||
assert_eq!(unsafe { verse_core_send_input_v1(core, &event) }, CANCELLED);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn destroy_timeout_keeps_ownership_suppresses_late_callbacks_and_allows_retry() {
|
||||
let mut ctx = Context::default();
|
||||
ctx.reentry_cancel.store(OK, Ordering::SeqCst);
|
||||
ctx.block_callbacks.store(true, Ordering::SeqCst);
|
||||
let core = create(&mut ctx);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), OK);
|
||||
wait_for(&ctx, |states| !states.is_empty());
|
||||
|
||||
assert_eq!(unsafe { verse_core_destroy_v1(core, 1) }, BUSY);
|
||||
let count_at_timeout = ctx.states.lock().expect("states").len();
|
||||
ctx.release_callbacks.store(true, Ordering::SeqCst);
|
||||
ctx.wake.notify_all();
|
||||
assert_eq!(destroy(core), OK);
|
||||
thread::sleep(Duration::from_millis(20));
|
||||
assert_eq!(ctx.states.lock().expect("states").len(), count_at_timeout);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn concurrent_cancel_and_destroy_do_not_race_lifetime() {
|
||||
let mut ctx = Context::default();
|
||||
ctx.reentry_cancel.store(OK, Ordering::SeqCst);
|
||||
let core = create(&mut ctx);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), OK);
|
||||
let barrier = Arc::new(Barrier::new(3));
|
||||
let core_address = core as usize;
|
||||
let cancel_barrier = Arc::clone(&barrier);
|
||||
let cancel = thread::spawn(move || {
|
||||
cancel_barrier.wait();
|
||||
// Test invariant: the main thread retains ownership across this overlapping call.
|
||||
unsafe { verse_core_cancel_v1(core_address as *mut Core) }
|
||||
});
|
||||
let destroy_barrier = Arc::clone(&barrier);
|
||||
let destroyer = thread::spawn(move || {
|
||||
destroy_barrier.wait();
|
||||
// Test invariant: this is the sole successful destroy attempt in the race.
|
||||
unsafe { verse_core_destroy_v1(core_address as *mut Core, 2_000) }
|
||||
});
|
||||
barrier.wait();
|
||||
let cancel_status = cancel.join().expect("cancel thread");
|
||||
let destroy_status = destroyer.join().expect("destroy thread");
|
||||
assert!(matches!(cancel_status, OK | INVALID_ARGUMENT));
|
||||
assert_eq!(destroy_status, OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn repeated_concurrent_cancel_destroy_cycles_are_safe() {
|
||||
for _ in 0..100 {
|
||||
let mut ctx = Context::default();
|
||||
ctx.reentry_cancel.store(OK, Ordering::SeqCst);
|
||||
let core = create(&mut ctx);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), OK);
|
||||
let barrier = Arc::new(Barrier::new(3));
|
||||
let address = core as usize;
|
||||
let cancel_barrier = Arc::clone(&barrier);
|
||||
let cancel = thread::spawn(move || {
|
||||
cancel_barrier.wait();
|
||||
unsafe { verse_core_cancel_v1(address as *mut Core) }
|
||||
});
|
||||
let destroy_barrier = Arc::clone(&barrier);
|
||||
let destroyer = thread::spawn(move || {
|
||||
destroy_barrier.wait();
|
||||
unsafe { verse_core_destroy_v1(address as *mut Core, 2_000) }
|
||||
});
|
||||
barrier.wait();
|
||||
assert!(matches!(
|
||||
cancel.join().expect("cancel"),
|
||||
OK | INVALID_ARGUMENT
|
||||
));
|
||||
assert_eq!(destroyer.join().expect("destroy"), OK);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preconnect_and_postcancel_state_checks_are_stable() {
|
||||
let mut ctx = Context::default();
|
||||
ctx.reentry_cancel.store(OK, Ordering::SeqCst);
|
||||
let core = create(&mut ctx);
|
||||
let event = keyboard_event();
|
||||
assert_eq!(
|
||||
unsafe { verse_core_send_input_v1(core, &event) },
|
||||
INVALID_STATE
|
||||
);
|
||||
assert_eq!(unsafe { verse_core_request_idr_v1(core) }, INVALID_STATE);
|
||||
assert_eq!(unsafe { verse_core_cancel_v1(core) }, OK);
|
||||
assert_eq!(connect(core, MANIFEST, CREDENTIAL), CANCELLED);
|
||||
assert_eq!(destroy(core), OK);
|
||||
}
|
||||
Reference in New Issue
Block a user