kmwebnet/OpenSK
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adapts libtock drivers for vendor HID (#500)

Browse Source 
* adapts libtock drivers for vendor HID

* status with timeout
This commit is contained in:
kaczmarczyck
2022-06-16 17:56:44 +02:00
committed by GitHub
parent 7e0c0938bb
commit 1d53f3c921
4 changed files with 117 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/env/tock/mod.rs vendored
View File

@@ -118,27 +118,27 @@ fn send_keepalive_up_needed(
channel: Channel,
timeout: Duration<isize>,
) -> Result<(), Ctap2StatusCode> {
let (interface, cid) = match channel {
Channel::MainHid(cid) => (usb_ctap_hid::UsbInterface::MainHid, cid),
let (endpoint, cid) = match channel {
Channel::MainHid(cid) => (usb_ctap_hid::UsbEndpoint::MainHid, cid),
#[cfg(feature = "vendor_hid")]
Channel::VendorHid(cid) => (usb_ctap_hid::UsbInterface::VendorHid, cid),
Channel::VendorHid(cid) => (usb_ctap_hid::UsbEndpoint::VendorHid, cid),
};
let keepalive_msg = CtapHid::keepalive(cid, KeepaliveStatus::UpNeeded);
for mut pkt in keepalive_msg {
let status = usb_ctap_hid::send_or_recv_with_timeout(&mut pkt, timeout, interface);
let status =
usb_ctap_hid::send_or_recv_with_timeout(&mut pkt, timeout, endpoint).flex_unwrap();
match status {
None => {
usb_ctap_hid::SendOrRecvStatus::Timeout => {
debug_ctap!(env, "Sending a KEEPALIVE packet timed out");
// TODO: abort user presence test?
}
Some(usb_ctap_hid::SendOrRecvStatus::Error) => panic!("Error sending KEEPALIVE packet"),
Some(usb_ctap_hid::SendOrRecvStatus::Sent) => {
usb_ctap_hid::SendOrRecvStatus::Sent => {
debug_ctap!(env, "Sent KEEPALIVE packet");
}
Some(usb_ctap_hid::SendOrRecvStatus::Received(received_interface)) => {
usb_ctap_hid::SendOrRecvStatus::Received(received_endpoint) => {
// We only parse one packet, because we only care about CANCEL.
let (received_cid, processed_packet) = CtapHid::process_single_packet(&pkt);
if received_interface != interface || received_cid != &cid {
if received_endpoint != endpoint || received_cid != &cid {
debug_ctap!(
env,
"Received a packet on channel ID {:?} while sending a KEEPALIVE packet",

40
src/main.rs
View File

@@ -42,7 +42,6 @@ use embedded_time::duration::Milliseconds;
use libtock_drivers::buttons::{self, ButtonState};
#[cfg(feature = "debug_ctap")]
use libtock_drivers::console::Console;
#[cfg(feature = "with_ctap1")]
use libtock_drivers::result::FlexUnwrap;
use libtock_drivers::timer::Duration;
use libtock_drivers::usb_ctap_hid;
@@ -89,15 +88,19 @@ fn main() {
}
let mut pkt_request = [0; 64];
let usb_interface =
match usb_ctap_hid::recv_with_timeout(&mut pkt_request, KEEPALIVE_DELAY_TOCK) {
Some(usb_ctap_hid::SendOrRecvStatus::Received(interface)) => {
let usb_endpoint =
match usb_ctap_hid::recv_with_timeout(&mut pkt_request, KEEPALIVE_DELAY_TOCK)
.flex_unwrap()
{
usb_ctap_hid::SendOrRecvStatus::Received(endpoint) => {
#[cfg(feature = "debug_ctap")]
print_packet_notice("Received packet", &clock);
Some(interface)
Some(endpoint)
}
Some(_) => panic!("Error receiving packet"),
None => None,
usb_ctap_hid::SendOrRecvStatus::Sent => {
panic!("Returned transmit status on receive")
}
usb_ctap_hid::SendOrRecvStatus::Timeout => None,
};
let now = clock.try_now().unwrap();
@@ -120,34 +123,31 @@ fn main() {
// don't cause problems with timers.
ctap.update_timeouts(now);
if let Some(interface) = usb_interface {
let transport = match interface {
usb_ctap_hid::UsbInterface::MainHid => Transport::MainHid,
if let Some(endpoint) = usb_endpoint {
let transport = match endpoint {
usb_ctap_hid::UsbEndpoint::MainHid => Transport::MainHid,
#[cfg(feature = "vendor_hid")]
usb_ctap_hid::UsbInterface::VendorHid => Transport::VendorHid,
usb_ctap_hid::UsbEndpoint::VendorHid => Transport::VendorHid,
};
let reply = ctap.process_hid_packet(&pkt_request, transport, now);
// This block handles sending packets.
for mut pkt_reply in reply {
let status = usb_ctap_hid::send_or_recv_with_timeout(
&mut pkt_reply,
SEND_TIMEOUT,
interface,
);
let status =
usb_ctap_hid::send_or_recv_with_timeout(&mut pkt_reply, SEND_TIMEOUT, endpoint)
.flex_unwrap();
match status {
None => {
usb_ctap_hid::SendOrRecvStatus::Timeout => {
#[cfg(feature = "debug_ctap")]
print_packet_notice("Sending packet timed out", &clock);
// TODO: reset the ctap_hid state.
// Since sending the packet timed out, we cancel this reply.
break;
}
Some(usb_ctap_hid::SendOrRecvStatus::Error) => panic!("Error sending packet"),
Some(usb_ctap_hid::SendOrRecvStatus::Sent) => {
usb_ctap_hid::SendOrRecvStatus::Sent => {
#[cfg(feature = "debug_ctap")]
print_packet_notice("Sent packet", &clock);
}
Some(usb_ctap_hid::SendOrRecvStatus::Received(_)) => {
usb_ctap_hid::SendOrRecvStatus::Received(_) => {
#[cfg(feature = "debug_ctap")]
print_packet_notice("Received an UNEXPECTED packet", &clock);
// TODO: handle this unexpected packet.