89 lines
3.3 KiB
Rust
89 lines
3.3 KiB
Rust
#[cfg(feature = "request_multiple")]
|
|
use crate::{
|
|
cbor::AuthenticatorData, FidoAssertionRequest, FidoCredential, FidoCredentialRequest,
|
|
FidoDevice, FidoErrorKind, FidoResult,
|
|
};
|
|
#[cfg(feature = "request_multiple")]
|
|
use crossbeam::thread;
|
|
#[cfg(feature = "request_multiple")]
|
|
use std::sync::mpsc::channel;
|
|
#[cfg(feature = "request_multiple")]
|
|
use std::time::Duration;
|
|
#[cfg(feature = "request_multiple")]
|
|
pub fn request_multiple_devices<
|
|
'a,
|
|
T: Send + 'a,
|
|
F: Fn(&mut FidoDevice) -> FidoResult<T> + 'a + Sync,
|
|
>(
|
|
devices: impl Iterator<Item = (&'a mut FidoDevice, &'a F)>,
|
|
timeout: Option<Duration>,
|
|
) -> FidoResult<T> {
|
|
thread::scope(|scope| -> FidoResult<T> {
|
|
let (tx, rx) = channel();
|
|
let handles = devices
|
|
.map(|(device, fn_)| {
|
|
let cancel = device.cancel_handle()?;
|
|
let tx = tx.clone();
|
|
let thread_handle = scope.spawn(move |_| tx.send(fn_(device)));
|
|
Ok((cancel, thread_handle))
|
|
})
|
|
.collect::<FidoResult<Vec<_>>>()?;
|
|
let mut err = None;
|
|
let mut slept = Duration::from_millis(0);
|
|
let interval = Duration::from_millis(10);
|
|
let mut received = 0usize;
|
|
let res = loop {
|
|
match timeout {
|
|
Some(t) if t < slept => {
|
|
break if let Some(cause) = err {
|
|
cause
|
|
} else {
|
|
Err(FidoErrorKind::Timeout.into())
|
|
};
|
|
}
|
|
_ => (),
|
|
}
|
|
if timeout.map(|t| t < slept).unwrap_or(true) {}
|
|
if let Ok(msg) = rx.recv_timeout(interval) {
|
|
received += 1;
|
|
match msg {
|
|
e @ Err(_) if received == handles.len() => break e,
|
|
e @ Err(_) => err = Some(e),
|
|
res @ Ok(_) => break res,
|
|
}
|
|
} else {
|
|
slept += interval;
|
|
}
|
|
};
|
|
for (mut cancel, join) in handles {
|
|
// Canceling out of courtesy don't care if it fails
|
|
let _ = cancel.cancel();
|
|
let _ = join.join();
|
|
}
|
|
res
|
|
})
|
|
.unwrap()
|
|
}
|
|
|
|
/// Will send the `assertion_request` to all supplied `devices` and return either the first successful assertion or the last error
|
|
#[cfg(feature = "request_multiple")]
|
|
pub fn get_assertion_devices<'a>(
|
|
assertion_request: &'a FidoAssertionRequest,
|
|
devices: impl Iterator<Item = &'a mut FidoDevice>,
|
|
timeout: Option<Duration>,
|
|
) -> FidoResult<(&'a FidoCredential, AuthenticatorData)> {
|
|
let get_assertion = |device: &mut FidoDevice| device.get_assertion(assertion_request);
|
|
request_multiple_devices(devices.map(|device| (device, &get_assertion)), timeout)
|
|
}
|
|
|
|
/// Will send the `credential_request` to all supplied `devices` and return either the first credential or the last error
|
|
#[cfg(feature = "request_multiple")]
|
|
pub fn make_credential_devices<'a>(
|
|
credential_request: &'a FidoCredentialRequest,
|
|
devices: impl Iterator<Item = &'a mut FidoDevice>,
|
|
timeout: Option<Duration>,
|
|
) -> FidoResult<FidoCredential> {
|
|
let make_credential = |device: &mut FidoDevice| device.make_credential(credential_request);
|
|
request_multiple_devices(devices.map(|device| (device, &make_credential)), timeout)
|
|
}
|