Moves Endpoint from libtock to API (#598)

The main benefit is that we removed all mentions of "tock" from all
source code that is not `main.rs` or inside `env/`.

This change makes libtock-drivers oblivious to how many endpoints are
supported. The endpoint is now checked a bit later in the stack.

Cargo.toml

@@ -32,7 +32,7 @@ std = ["crypto/std", "lang_items/std", "persistent_store/std", "rng256/std", "ra
 verbose = ["debug_ctap", "libtock_drivers/verbose_usb"]
 with_ctap1 = ["crypto/with_ctap1"]
 with_nfc = ["libtock_drivers/with_nfc"]
-vendor_hid = ["libtock_drivers/vendor_hid"]
+vendor_hid = []
 fuzz = ["arbitrary", "std"]
 ed25519 = ["ed25519-compact"]
 

src/api/connection.rs

@@ -12,7 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use libtock_drivers::usb_ctap_hid::UsbEndpoint;
+use core::convert::TryFrom;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum UsbEndpoint {
+    MainHid = 1,
+    #[cfg(feature = "vendor_hid")]
+    VendorHid = 2,
+}
+
+impl TryFrom<usize> for UsbEndpoint {
+    type Error = SendOrRecvError;
+
+    fn try_from(endpoint_num: usize) -> Result<Self, SendOrRecvError> {
+        match endpoint_num {
+            1 => Ok(UsbEndpoint::MainHid),
+            #[cfg(feature = "vendor_hid")]
+            2 => Ok(UsbEndpoint::VendorHid),
+            _ => Err(SendOrRecvError),
+        }
+    }
+}
 
 pub enum SendOrRecvStatus {
     Timeout,

src/ctap/mod.rs

@@ -65,7 +65,7 @@ use self::status_code::Ctap2StatusCode;
 use self::u2f_up::U2fUserPresenceState;
 use crate::api::attestation_store::{self, Attestation, AttestationStore};
 use crate::api::clock::Clock;
-use crate::api::connection::{HidConnection, SendOrRecvStatus};
+use crate::api::connection::{HidConnection, SendOrRecvStatus, UsbEndpoint};
 use crate::api::customization::Customization;
 use crate::api::firmware_protection::FirmwareProtection;
 use crate::api::upgrade_storage::UpgradeStorage;
@@ -80,7 +80,6 @@ use core::convert::TryFrom;
 use crypto::hmac::hmac_256;
 use crypto::sha256::Sha256;
 use crypto::{ecdsa, Hash256};
-use libtock_drivers::usb_ctap_hid::UsbEndpoint;
 use rng256::Rng256;
 use sk_cbor as cbor;
 use sk_cbor::cbor_map_options;

src/env/tock/mod.rs

@@ -14,7 +14,9 @@
 
 pub use self::storage::{TockStorage, TockUpgradeStorage};
 use crate::api::attestation_store::AttestationStore;
-use crate::api::connection::{HidConnection, SendOrRecvError, SendOrRecvResult, SendOrRecvStatus};
+use crate::api::connection::{
+    HidConnection, SendOrRecvError, SendOrRecvResult, SendOrRecvStatus, UsbEndpoint,
+};
 use crate::api::customization::{CustomizationImpl, DEFAULT_CUSTOMIZATION};
 use crate::api::firmware_protection::FirmwareProtection;
 use crate::api::user_presence::{UserPresence, UserPresenceError, UserPresenceResult};
@@ -22,14 +24,14 @@ use crate::api::{attestation_store, key_store};
 use crate::env::Env;
 use clock::TockClock;
 use core::cell::Cell;
+use core::convert::TryFrom;
 use core::sync::atomic::{AtomicBool, Ordering};
 use libtock_core::result::{CommandError, EALREADY};
 use libtock_drivers::buttons::{self, ButtonState};
 use libtock_drivers::console::Console;
 use libtock_drivers::result::{FlexUnwrap, TockError};
 use libtock_drivers::timer::Duration;
-use libtock_drivers::usb_ctap_hid::{self, UsbEndpoint};
-use libtock_drivers::{crp, led, timer};
+use libtock_drivers::{crp, led, timer, usb_ctap_hid};
 use persistent_store::{StorageResult, Store};
 use rng256::TockRng256;
 
@@ -45,12 +47,12 @@ impl HidConnection for TockHidConnection {
         match usb_ctap_hid::send_or_recv_with_timeout(
             buf,
             Duration::from_ms(timeout_ms as isize),
-            self.endpoint,
+            self.endpoint as usize,
         ) {
             Ok(usb_ctap_hid::SendOrRecvStatus::Timeout) => Ok(SendOrRecvStatus::Timeout),
             Ok(usb_ctap_hid::SendOrRecvStatus::Sent) => Ok(SendOrRecvStatus::Sent),
             Ok(usb_ctap_hid::SendOrRecvStatus::Received(recv_endpoint)) => {
-                Ok(SendOrRecvStatus::Received(recv_endpoint))
+                UsbEndpoint::try_from(recv_endpoint).map(SendOrRecvStatus::Received)
             }
             _ => Err(SendOrRecvError),
         }

src/main.rs

@@ -23,10 +23,11 @@ extern crate lang_items;
 
 #[cfg(feature = "with_ctap1")]
 use core::cell::Cell;
+use core::convert::TryFrom;
 #[cfg(feature = "debug_ctap")]
 use core::fmt::Write;
 use ctap2::api::clock::Clock;
-use ctap2::api::connection::{HidConnection, SendOrRecvStatus};
+use ctap2::api::connection::{HidConnection, SendOrRecvStatus, UsbEndpoint};
 use ctap2::ctap::hid::HidPacketIterator;
 use ctap2::ctap::KEEPALIVE_DELAY_MS;
 #[cfg(feature = "with_ctap1")]
@@ -41,7 +42,6 @@ use libtock_drivers::console::Console;
 use libtock_drivers::result::FlexUnwrap;
 use libtock_drivers::timer::Duration;
 use libtock_drivers::usb_ctap_hid;
-use usb_ctap_hid::UsbEndpoint;
 
 libtock_core::stack_size! {0x4000}
 
@@ -189,7 +189,7 @@ fn main() {
                     usb_ctap_hid::SendOrRecvStatus::Received(endpoint) => {
                         #[cfg(feature = "debug_ctap")]
                         print_packet_notice("Received packet", ctap.env().clock().timestamp_us());
-                        Some(endpoint)
+                        UsbEndpoint::try_from(endpoint).ok()
                     }
                     usb_ctap_hid::SendOrRecvStatus::Sent => {
                         panic!("Returned transmit status on receive")

third_party/libtock-drivers/Cargo.toml

@@ -13,6 +13,5 @@ libtock_core = { path = "../../third_party/libtock-rs/core" }
 
 [features]
 debug_ctap = []
-vendor_hid = []
 verbose_usb = ["debug_ctap"]
 with_nfc=[]

third_party/libtock-drivers/src/usb_ctap_hid.rs

@@ -18,7 +18,6 @@ use crate::result::{OutOfRangeError, TockError, TockResult};
 use crate::timer::Duration;
 use crate::{timer, util};
 use core::cell::Cell;
-use core::convert::TryFrom;
 #[cfg(feature = "debug_ctap")]
 use core::fmt::Write;
 use libtock_core::result::{CommandError, EALREADY, EBUSY, SUCCESS};
@@ -65,31 +64,11 @@ pub fn setup() -> bool {
     true
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum UsbEndpoint {
-    MainHid = 1,
-    #[cfg(feature = "vendor_hid")]
-    VendorHid = 2,
-}
-
-impl TryFrom<usize> for UsbEndpoint {
-    type Error = TockError;
-
-    fn try_from(endpoint_num: usize) -> Result<Self, TockError> {
-        match endpoint_num {
-            1 => Ok(UsbEndpoint::MainHid),
-            #[cfg(feature = "vendor_hid")]
-            2 => Ok(UsbEndpoint::VendorHid),
-            _ => Err(OutOfRangeError.into()),
-        }
-    }
-}
-
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum SendOrRecvStatus {
     Timeout,
     Sent,
-    Received(UsbEndpoint),
+    Received(usize),
 }
 
 /// Waits to receive a packet.
@@ -116,7 +95,7 @@ pub fn recv_with_timeout(
             Console::new(),
             "Received packet = {:02x?} on endpoint {}",
             buf as &[u8],
-            endpoint as u8,
+            endpoint,
         )
         .unwrap();
     }
@@ -140,7 +119,7 @@ pub fn recv_with_timeout(
 pub fn send_or_recv_with_timeout(
     buf: &mut [u8; 64],
     timeout_delay: Duration<isize>,
-    endpoint: UsbEndpoint,
+    endpoint: usize,
 ) -> TockResult<SendOrRecvStatus> {
     #[cfg(feature = "verbose_usb")]
     writeln!(
@@ -159,7 +138,7 @@ pub fn send_or_recv_with_timeout(
             Console::new(),
             "Received packet = {:02x?} on endpoint {}",
             buf as &[u8],
-            received_endpoint as u8,
+            received_endpoint,
         )
         .unwrap();
     }
@@ -176,9 +155,7 @@ fn recv_with_timeout_detail(
     let status = Cell::new(None);
     let mut alarm = |direction, endpoint| {
         status.set(Some(match direction {
-            subscribe_nr::callback_status::RECEIVED => {
-                UsbEndpoint::try_from(endpoint).map(|i| SendOrRecvStatus::Received(i))
-            }
+            subscribe_nr::callback_status::RECEIVED => Ok(SendOrRecvStatus::Received(endpoint)),
             // Unknown direction or "transmitted" sent by the kernel.
             _ => Err(OutOfRangeError.into()),
         }));
@@ -260,7 +237,7 @@ fn recv_with_timeout_detail(
 fn send_or_recv_with_timeout_detail(
     buf: &mut [u8; 64],
     timeout_delay: Duration<isize>,
-    endpoint: UsbEndpoint,
+    endpoint: usize,
 ) -> TockResult<SendOrRecvStatus> {
     let result = syscalls::allow(DRIVER_NUMBER, allow_nr::TRANSMIT_OR_RECEIVE, buf)?;
 
@@ -268,9 +245,7 @@ fn send_or_recv_with_timeout_detail(
     let mut alarm = |direction, endpoint| {
         status.set(Some(match direction {
             subscribe_nr::callback_status::TRANSMITTED => Ok(SendOrRecvStatus::Sent),
-            subscribe_nr::callback_status::RECEIVED => {
-                UsbEndpoint::try_from(endpoint).map(|i| SendOrRecvStatus::Received(i))
-            }
+            subscribe_nr::callback_status::RECEIVED => Ok(SendOrRecvStatus::Received(endpoint)),
             // Unknown direction sent by the kernel.
             _ => Err(OutOfRangeError.into()),
         }));