tests/fido2-tests: cleanup u2f-tests-hid

tests/fido_tests/u2f-tests-hid/HIDTest.cc

@@ -34,7 +34,7 @@ void checkPause() {
 static
 void AbortOrNot() {
   checkPause();
-  if (arg_Abort) abort();
+  if (arg_Abort) exit(3);
   cerr << "(continuing -a)" << endl;
 }
 
@@ -138,9 +138,9 @@ void test_LongEcho() {
   // Expected transfer times for 2ms bInterval.
   // We do not want fobs to be too slow or too agressive.
   if (device->dev != NULL) {
-    // CHECK_GE(sent, .020);
+    CHECK_GE(sent, .020);
     CHECK_LE(sent, .075);
-    // CHECK_GE(received, .020);
+    CHECK_GE(received, .020);
     CHECK_LE(received, .075);
   }
 }

tests/fido_tests/u2f-tests-hid/Makefile

@@ -23,4 +23,4 @@ U2FTest: dev.o U2FTest.o u2f_util.o dsa_sig.o hidapi-udp.o p256.o p256_ec.o p256
 	$(CXX) $(CFLAGS) -o $@ $^
 
 clean:
-	rm -f *.o U2FTest
+	rm -f *.o HIDTest U2FTest

tests/fido_tests/u2f-tests-hid/U2FTest.cc

@@ -49,7 +49,7 @@ void checkPause(const string& prompt) {
 static
 void AbortOrNot() {
   checkPause("Hit enter to continue..");
-  if (arg_Abort) abort();
+  if (arg_Abort) exit(3);
   cerr << "(continuing -a)" << endl;
 }
 
@@ -377,9 +377,8 @@ int main(int argc, char* argv[]) {
   CHECK_EQ(ctr2, ctr1 + 1);
 
   regRsp.keyHandleLen -= 8; // perturb keyhandle length
-  PASS(test_Sign(0x6A80, false));
+  PASS(test_Sign(0x6a80, false));
 
-  //DEV_quit(device); // stop emulator, if any
   U2Fob_destroy(device);
   return 0;
 }

tests/fido_tests/u2f-tests-hid/dev.cc

@@ -16,7 +16,7 @@
 #include "u2f_util.h"
 
 bool DEV_opened(struct U2Fob* device) {
-  return device->dev != NULL || (device->fd_in != -1 && device->fd_out != -1);
+  return device->dev != NULL;
 }
 
 void DEV_close(struct U2Fob* device) {
@@ -24,124 +24,23 @@ void DEV_close(struct U2Fob* device) {
     hid_close(device->dev);
     device->dev = NULL;
   }
-  if (device->fd_in != -1) {
-    close(device->fd_in);
-    device->fd_in = -1;
-  }
-  if (device->fd_out != -1) {
-    close(device->fd_out);
-    device->fd_out = -1;
-  }
 }
 
 void DEV_open_path(struct U2Fob* device) {
-  std::string path(device->path);
-  if (path[path.size() - 1] == '-') {
-    device->fd_in = open((path + "out").c_str(), O_RDONLY);
-    device->fd_out = open((path + "in").c_str(), O_RDWR);
-  } else {
-    device->dev = hid_open_path(device->path);
-  }
-}
-
-void DEV_quit(struct U2Fob* device) {
-  if (device->dev) return;
-
-  struct {
-    uint32_t cmd;
-    uint32_t len;
-    uint32_t mode;
-  } data;
-
-  data.cmd = htole32(2);  // kReset
-  data.len = htole32(4);
-  data.mode = htole32(3);  // kResetQuit
-  assert(write(device->fd_out, (const void*)&data, sizeof(data)) == sizeof(data));
+  device->dev = hid_open_path(device->path);
 }
 
 int DEV_write(struct U2Fob* device, const uint8_t* src, size_t n) {
   assert(n == 65);
-
-  if (device->dev != NULL) return hid_write(device->dev, src, n);
-
-  struct {
-    uint32_t cmd;
-    uint32_t len;
-    uint8_t data[64];
-  } data;
-
-  static_assert(sizeof(data) == 64 + 8);
-
-  data.cmd = htole32(4);  // k64ByteWrite
-  data.len = htole32(64);
-  memcpy(data.data, src + 1, 64);
-
-  int nwritten = write(device->fd_out, (const void*)&data, sizeof(data));
-  assert(nwritten == sizeof(data));
-  usleep(1500);  // delay a bit to mimic HID transport.
-  return 65;
+  return hid_write(device->dev, src, n);
 }
 
 int DEV_read_timeout(struct U2Fob* device, uint8_t* dst, size_t n,
                      int timeout) {
   assert(n == 64);
-
-  if (device->dev != NULL)
-    return hid_read_timeout(device->dev, dst, n, timeout);
-
-  struct {
-    uint32_t cmd;
-    uint32_t len;
-  } data;
-
-  static_assert(sizeof(data) == 8);
-
-  data.cmd = htole32(5);  // k64ByteRead
-  data.len = htole32(0);
-
-  uint64_t t0, t1;
-  float dt;
-  U2Fob_deltaTime(&t0);
-
-  // Poll until timeout
-  do {
-    assert(write(device->fd_out, (uint8_t*)&data, sizeof(data)) ==
-           sizeof(data));
-    assert(read(device->fd_in, (uint8_t*)&data, sizeof(data)) == sizeof(data));
-
-    assert(data.cmd == htole32(5));
-    if (data.len == htole32(64)) break;
-
-    assert(data.len == 0);
-
-    usleep(100);
-
-    t1 = t0;
-    dt = U2Fob_deltaTime(&t1);
-  } while (dt < timeout / 1000.0);
-
-  if (data.len == 0) return 0;
-
-  assert(data.len == htole32(64));
-  assert(read(device->fd_in, dst, 64) == 64);
-  return 64;
+  return hid_read_timeout(device->dev, dst, n, timeout);
 }
 
 int DEV_touch(struct U2Fob* device) {
-  if (device->dev != NULL) return 0;
-
-  struct {
-    uint32_t cmd;
-    uint32_t len;
-    uint32_t number;
-  } data;
-
-  static_assert(sizeof(data) == 12);
-
-  data.cmd = htole32(6);  // kRaiseInterrupt
-  data.len = htole32(sizeof(uint32_t));
-  data.number = htole32(199);  // touch toggle handler
-
-  assert(write(device->fd_out, (uint8_t*)&data, sizeof(data)) == sizeof(data));
-  return 1;
+  return 0;
 }

tests/fido_tests/u2f-tests-hid/hidapi-udp.c

@@ -62,6 +62,10 @@ void hid_close(hid_device *device) {
 }
 
 int hid_write(hid_device *device, const unsigned char *data, size_t length) {
+  if (!device) {
+    fprintf(stderr, "Device can't be NULL\n");
+    return -1;
+  }
   if (length != 65) {
     fprintf(stderr, "Invalid packet size\n");
     return -1;
@@ -71,15 +75,20 @@ int hid_write(hid_device *device, const unsigned char *data, size_t length) {
     fprintf(stderr, "Failed to write socket\n");
     return -1;
   }
+  usleep(1000);
   return length;
 }
 
 int hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds) {
+  if (!device) {
+    fprintf(stderr, "Device can't be NULL\n");
+    return -1;
+  }
   for (int i = 0; i < milliseconds; i++) {
+    usleep(1000);
     ssize_t n = recvfrom(device->fd, data, length, MSG_DONTWAIT, (struct sockaddr *)&(device->other), &(device->slen));
     if (n < 0) {
       if (errno == EAGAIN && errno == EWOULDBLOCK) { // timeout tick
-        usleep(1000);
         continue;
       } else {
         fprintf(stderr, "Failed to read socket\n");

tests/fido_tests/u2f-tests-hid/u2f_util.cc

@@ -101,7 +101,7 @@ struct U2Fob* U2Fob_create() {
   if (hid_init() == 0) {
     f = (struct U2Fob*)malloc(sizeof(struct U2Fob));
     memset(f, 0, sizeof(struct U2Fob));
-    f->cid = f->fd_in = f->fd_out = -1;
+    f->cid = -1;
   }
   return f;
 }

tests/fido_tests/u2f-tests-hid/u2f_util.h

@@ -72,8 +72,7 @@ float U2Fob_deltaTime(uint64_t* state);
 
 struct U2Fob {
   hid_device* dev;
-  int fd_in;
-  int fd_out;
+  hid_device* dev_debug;
   char* path;
   uint32_t cid;
   int loglevel;
@@ -153,6 +152,5 @@ void DEV_open_path(struct U2Fob* device);
 int DEV_write(struct U2Fob* device, const uint8_t* src, size_t n);
 int DEV_read_timeout(struct U2Fob* device, uint8_t* dst, size_t n, int timeout);
 int DEV_touch(struct U2Fob* device);
-void DEV_quit(struct U2Fob* device);
 
 #endif  // __U2F_UTIL_H_INCLUDED__