WIP win-vhid iter7: provider-based trigger using device FeatureReportByteLength

Author: Youw

src/tests/CMakeLists.txt

@@ -42,6 +42,10 @@ set_target_properties(test_read_interrupt
         C_STANDARD_REQUIRED TRUE
 )
 target_link_libraries(test_read_interrupt PRIVATE ${HIDAPI_TEST_BACKEND} Threads::Threads)
+if(WIN32)
+    # HidD_GetPreparsedData / HidP_GetCaps used by the Windows provider.
+    target_link_libraries(test_read_interrupt PRIVATE hid)
+endif()
 
 add_test(NAME ReadInterrupt COMMAND test_read_interrupt)
 set_tests_properties(ReadInterrupt

src/tests/test_read_interrupt.c

@@ -77,10 +77,7 @@ static int test_normal_read(test_virtual_device *vdev)
 	unsigned char buf[64];
 	int n;
 
-	int tr = test_virtual_device_trigger(h, TEST_VDEV_CMD_EMIT_A);
-	if (tr < 0)
-		printf("    trigger A returned %d, hid_error: %ls\n", tr, hid_error(h));
-	CHECK(tr >= 0);
+	CHECK(test_virtual_device_trigger(vdev, h, TEST_VDEV_CMD_EMIT_A) >= 0);
 	n = hid_read_timeout(h, buf, sizeof(buf), 2000);
 	CHECK(n == (int)sizeof(expected));
 	CHECK(memcmp(buf, expected, sizeof(expected)) == 0);
@@ -221,7 +218,7 @@ static int test_clear_resumes_reads(test_virtual_device *vdev)
 	CHECK(n == 0);
 
 	const unsigned char expected[TEST_VDEV_REPORT_SIZE] = TEST_VDEV_INPUT_B;
-	CHECK(test_virtual_device_trigger(h, TEST_VDEV_CMD_EMIT_B) >= 0);
+	CHECK(test_virtual_device_trigger(vdev, h, TEST_VDEV_CMD_EMIT_B) >= 0);
 	n = hid_read_timeout(h, buf, sizeof(buf), 2000);
 	CHECK(n == (int)sizeof(expected));
 	CHECK(memcmp(buf, expected, sizeof(expected)) == 0);

src/tests/test_virtual_device.h

@@ -93,19 +93,15 @@ void test_virtual_device_destroy(test_virtual_device *dev);
 
 /*
  * Trigger a pre-recorded scenario on the device by sending the given command
- * as the first byte of a Feature report. This is implemented purely on top of
- * the public HIDAPI API, so it is identical for every backend.
+ * as the first byte of a Feature report, using the ordinary public HIDAPI
+ * hid_send_feature_report(). The exact wire length of a feature report is
+ * platform-specific (Windows requires the buffer to be exactly the device's
+ * FeatureReportByteLength), so this is implemented per-provider.
  *
- * Returns the hid_send_feature_report() result (>= 0 on success, -1 on error).
+ * Returns >= 0 on success, -1 on error.
  */
-static inline int test_virtual_device_trigger(hid_device *handle, unsigned char command)
-{
-	unsigned char feature[1 + TEST_VDEV_REPORT_SIZE];
-	memset(feature, 0, sizeof(feature));
-	feature[0] = 0x00;        /* Report ID (the device has no numbered reports) */
-	feature[1] = command;     /* scenario command, first byte of the payload */
-	return hid_send_feature_report(handle, feature, sizeof(feature));
-}
+int test_virtual_device_trigger(test_virtual_device *dev, hid_device *handle,
+                                unsigned char command);
 
 #ifdef __cplusplus
 }

src/tests/test_virtual_device_uhid.c

@@ -317,6 +317,17 @@ hid_device *test_virtual_device_open_hidapi(test_virtual_device *dev, int timeou
 	}
 }
 
+int test_virtual_device_trigger(test_virtual_device *dev, hid_device *handle,
+                                unsigned char command)
+{
+	unsigned char feature[1 + TEST_VDEV_REPORT_SIZE];
+	(void)dev;
+	memset(feature, 0, sizeof(feature));
+	feature[0] = 0x00;        /* Report ID (the device has no numbered reports) */
+	feature[1] = command;     /* scenario command, first byte of the payload */
+	return hid_send_feature_report(handle, feature, sizeof(feature));
+}
+
 void test_virtual_device_destroy(test_virtual_device *dev)
 {
 	struct uhid_event ev;

src/tests/test_virtual_device_win.c

@@ -11,29 +11,31 @@
 
 /*
  * On Windows there is no userspace facility to create a HID device on the fly
- * (unlike Linux /dev/uhid). Instead, a small UMDF virtual HID driver
+ * (unlike Linux /dev/uhid). A small UMDF virtual HID driver
  * (src/tests/windows/driver, a modified vhidmini2) is built, signed and
- * installed out-of-band - by the CI job - before the test runs, and removed
+ * installed out-of-band by the CI job before the test runs, and removed
  * afterwards. That driver implements the same pre-recorded scenario protocol
  * as the Linux uhid provider (see test_virtual_device.h).
  *
- * Therefore this provider does not itself create the device: create() simply
- * records the ids, and presence is confirmed by open_hidapi() (and the test's
- * own probe), which polls HIDAPI enumeration. If the device isn't present
- * (driver not installed, e.g. a normal dev machine) the test skips.
+ * create() just records the ids; presence is confirmed by open_hidapi(), which
+ * also caches the device's feature-report length so that trigger() can send a
+ * feature report of exactly the size Windows requires.
  */
 
 #include "test_virtual_device.h"
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <wchar.h>
 #include <windows.h>
+#include <hidsdi.h>
+#include <hidpi.h>
 
 struct test_virtual_device {
 	unsigned short vendor_id;
 	unsigned short product_id;
 	char serial[64];
+	ULONG feature_len;      /* FeatureReportByteLength of the opened device */
 };
 
 int test_virtual_device_create(test_virtual_device **out_dev,
@@ -62,6 +64,34 @@ int test_virtual_device_create(test_virtual_device **out_dev,
 	return TEST_VDEV_OK;
 }
 
+/* Query the device's HID caps (report byte lengths) directly from Windows. */
+static ULONG query_feature_len(const char *path)
+{
+	HANDLE h;
+	PHIDP_PREPARSED_DATA pp = NULL;
+	ULONG feat = 0;
+
+	h = CreateFileA(path, GENERIC_READ | GENERIC_WRITE,
+	                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+	                OPEN_EXISTING, 0, NULL);
+	if (h == INVALID_HANDLE_VALUE)
+		return 0;
+
+	if (HidD_GetPreparsedData(h, &pp)) {
+		HIDP_CAPS caps;
+		if (HidP_GetCaps(pp, &caps) == HIDP_STATUS_SUCCESS) {
+			printf("    device caps: input=%u output=%u feature=%u\n",
+			       (unsigned)caps.InputReportByteLength,
+			       (unsigned)caps.OutputReportByteLength,
+			       (unsigned)caps.FeatureReportByteLength);
+			feat = caps.FeatureReportByteLength;
+		}
+		HidD_FreePreparsedData(pp);
+	}
+	CloseHandle(h);
+	return feat;
+}
+
 hid_device *test_virtual_device_open_hidapi(test_virtual_device *dev, int timeout_ms)
 {
 	int waited = 0;
@@ -71,16 +101,13 @@ hid_device *test_virtual_device_open_hidapi(test_virtual_device *dev, int timeou
 
 	for (;;) {
 		struct hid_device_info *infos = hid_enumerate(dev->vendor_id, dev->product_id);
-		struct hid_device_info *cur;
-		struct hid_device_info *first = NULL;
 		hid_device *h = NULL;
 
-		for (cur = infos; cur; cur = cur->next) {
-			if (!first)
-				first = cur;
+		if (infos) {
+			if (dev->feature_len == 0)
+				dev->feature_len = query_feature_len(infos->path);
+			h = hid_open_path(infos->path);
 		}
-		if (first)
-			h = hid_open_path(first->path);
 		hid_free_enumeration(infos);
 		if (h)
 			return h;
@@ -92,6 +119,22 @@ hid_device *test_virtual_device_open_hidapi(test_virtual_device *dev, int timeou
 	}
 }
 
+int test_virtual_device_trigger(test_virtual_device *dev, hid_device *handle,
+                                unsigned char command)
+{
+	unsigned char feature[256];
+	size_t len = (1 + TEST_VDEV_REPORT_SIZE);
+
+	/* Windows requires the feature buffer to be exactly FeatureReportByteLength. */
+	if (dev && dev->feature_len > 0 && dev->feature_len <= sizeof(feature))
+		len = dev->feature_len;
+
+	memset(feature, 0, sizeof(feature));
+	feature[0] = 0x00;        /* Report ID (the device has no numbered reports) */
+	feature[1] = command;     /* scenario command, first byte of the payload */
+	return hid_send_feature_report(handle, feature, len);
+}
+
 void test_virtual_device_destroy(test_virtual_device *dev)
 {
 	/* The harness uninstalls the driver/device after the test. */