usb 2.16.0 → 2.18.0

package/libusb/libusb/os/threads_windows.h

@@ -50,7 +50,8 @@ static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
 }
 static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
 {
-	return TryEnterCriticalSection(mutex) != 0;
+    int mutexIsLocked = TryEnterCriticalSection(mutex) != 0;
+    return mutexIsLocked;
 }
 static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
 {
@@ -105,9 +106,9 @@ static inline void usbi_tls_key_delete(usbi_tls_key_t key)
 	WINAPI_CHECK(TlsFree(key));
 }
 
-static inline unsigned int usbi_get_tid(void)
+static inline unsigned long usbi_get_tid(void)
 {
-	return (unsigned int)GetCurrentThreadId();
+	return (unsigned long)GetCurrentThreadId();
 }
 
 #endif /* LIBUSB_THREADS_WINDOWS_H */

package/libusb/libusb/os/windows_common.c

@@ -29,6 +29,10 @@
 #include "libusbi.h"
 #include "windows_common.h"
 
+#if defined(LIBUSB_WINDOWS_HOTPLUG)
+#include "windows_hotplug.h"
+#endif
+
 #define EPOCH_TIME	UINT64_C(116444736000000000)	// 1970.01.01 00:00:000 in MS Filetime
 
 #define STATUS_SUCCESS	((ULONG_PTR)0UL)
@@ -492,9 +496,11 @@ static unsigned __stdcall windows_iocp_thread(void *arg)
 		}
 
 		itransfer = TRANSFER_PRIV_TO_USBI_TRANSFER(transfer_priv);
+#ifdef ENABLE_LOGGING
 		struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 		usbi_dbg(ctx, "transfer %p completed, length %lu",
 			 transfer, ULONG_CAST(num_bytes));
+#endif
 		usbi_signal_transfer_completion(itransfer);
 	}
 
@@ -565,6 +571,18 @@ static int windows_init(struct libusb_context *ctx)
 
 	r = LIBUSB_SUCCESS;
 
+#if defined(LIBUSB_WINDOWS_HOTPLUG)
+	if (init_count == 1) {
+		r = windows_start_event_monitor(); // Start-up hotplug event handler
+		if (r != LIBUSB_SUCCESS) {
+			usbi_err(ctx, "error starting hotplug event monitor");
+			goto init_exit;
+		}
+	}
+
+	windows_initial_scan_devices(ctx);
+#endif
+
 init_exit: // Holds semaphore here
 	if ((init_count == 1) && (r != LIBUSB_SUCCESS)) { // First init failed?
 		if (usbdk_available) {
@@ -596,6 +614,9 @@ static void windows_exit(struct libusb_context *ctx)
 
 	// Only works if exits and inits are balanced exactly
 	if (--init_count == 0) { // Last exit
+#if defined(LIBUSB_WINDOWS_HOTPLUG)
+		windows_stop_event_monitor();
+#endif
 		if (usbdk_available) {
 			usbdk_backend.exit(ctx);
 			usbdk_available = false;
@@ -624,11 +645,23 @@ static int windows_set_option(struct libusb_context *ctx, enum libusb_option opt
 	return LIBUSB_ERROR_NOT_SUPPORTED;
 }
 
+#if !defined(LIBUSB_WINDOWS_HOTPLUG)
 static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs)
 {
 	struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 	return priv->backend->get_device_list(ctx, discdevs);
 }
+#endif
+
+static int windows_get_device_string(libusb_device *dev,
+	enum libusb_device_string_type string_type, char *data, int length)
+{
+	struct windows_context_priv* priv = usbi_get_context_priv(DEVICE_CTX(dev));
+	if (NULL != priv->backend->get_device_string) {
+		return priv->backend->get_device_string(dev, string_type, data, length);
+	}
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
 
 static int windows_open(struct libusb_device_handle *dev_handle)
 {
@@ -717,6 +750,37 @@ static void windows_destroy_device(struct libusb_device *dev)
 	priv->backend->destroy_device(dev);
 }
 
+static int windows_endpoint_supports_raw_io(libusb_device_handle* dev_handle,
+	uint8_t endpoint)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	if (priv->backend->endpoint_supports_raw_io)
+		return priv->backend->endpoint_supports_raw_io(dev_handle, endpoint);
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int windows_endpoint_set_raw_io(libusb_device_handle* dev_handle,
+	uint8_t endpoint, int enable)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+
+	if (priv->backend->endpoint_supports_raw_io == NULL
+		|| priv->backend->endpoint_supports_raw_io(dev_handle, endpoint) != 1
+		|| priv->backend->endpoint_set_raw_io == NULL)
+		return LIBUSB_ERROR_NOT_SUPPORTED;
+
+	return priv->backend->endpoint_set_raw_io(dev_handle, endpoint, enable);
+}
+
+static int windows_get_max_raw_io_transfer_size(struct libusb_device_handle *dev_handle,
+	uint8_t endpoint)
+{
+	struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
+	if (priv->backend->get_max_raw_io_transfer_size)
+		return priv->backend->get_max_raw_io_transfer_size(dev_handle, endpoint);
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
 static int windows_submit_transfer(struct usbi_transfer *itransfer)
 {
 	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
@@ -800,15 +864,26 @@ static int windows_handle_transfer_completion(struct usbi_transfer *itransfer)
 	struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 	enum libusb_transfer_status status, istatus;
 	DWORD result, bytes_transferred;
+	HANDLE transfer_handle;
+
+	/*
+	 * The submit path runs with itransfer->lock held. Grab the handle under
+	 * the same lock so we do not race with submission/completion bookkeeping.
+	 */
+	usbi_mutex_lock(&itransfer->lock);
+	transfer_handle = transfer_priv->handle;
+	usbi_mutex_unlock(&itransfer->lock);
 
-	if (GetOverlappedResult(transfer_priv->handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
+	if (GetOverlappedResult(transfer_handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
 		result = NO_ERROR;
 	else
 		result = GetLastError();
 
+#ifdef ENABLE_LOGGING
 	struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 	usbi_dbg(ctx, "handling transfer %p completion with errcode %lu, length %lu",
 		 transfer, ULONG_CAST(result), ULONG_CAST(bytes_transferred));
+#endif
 
 	switch (result) {
 	case NO_ERROR:
@@ -843,7 +918,9 @@ static int windows_handle_transfer_completion(struct usbi_transfer *itransfer)
 		break;
 	}
 
+	usbi_mutex_lock(&itransfer->lock);
 	transfer_priv->handle = NULL;
+	usbi_mutex_unlock(&itransfer->lock);
 
 	// Backend-specific cleanup
 	backend->clear_transfer_priv(itransfer);
@@ -888,7 +965,12 @@ const struct usbi_os_backend usbi_backend = {
 	windows_init,
 	windows_exit,
 	windows_set_option,
+#if defined(LIBUSB_WINDOWS_HOTPLUG)
+	NULL, /* get_device_list */
+#else
 	windows_get_device_list,
+#endif
+	windows_get_device_string,
 	NULL,	/* hotplug_poll */
 	NULL,	/* wrap_sys_device */
 	windows_open,
@@ -910,6 +992,9 @@ const struct usbi_os_backend usbi_backend = {
 	NULL,	/* kernel_driver_active */
 	NULL,	/* detach_kernel_driver */
 	NULL,	/* attach_kernel_driver */
+	windows_endpoint_supports_raw_io,
+	windows_endpoint_set_raw_io,
+	windows_get_max_raw_io_transfer_size,
 	windows_destroy_device,
 	windows_submit_transfer,
 	windows_cancel_transfer,

package/libusb/libusb/os/windows_common.h

@@ -242,13 +242,23 @@ struct usbdk_device_priv {
 
 struct winusb_device_priv {
 	bool initialized;
+#if defined(LIBUSB_WINDOWS_HOTPLUG)
+	bool seen_during_scan; // set true for each device encountered during windows_get_device_list
+	bool seen_before_scan; // set true for each device encountered before windows_get_device_list
+#endif
 	bool root_hub;
 	uint8_t active_config;
+	uint16_t langid; // cached USB language ID for string descriptor requests
 	uint8_t depth; // distance to HCD
 	const struct windows_usb_api_backend *apib;
 	char *dev_id;
 	char *path;  // device interface path
 	int sub_api; // for WinUSB-like APIs
+	usbi_mutex_t interface_lock; // protects usb_interface[] against concurrent
+	                             // claim/release/altsetting from different handles,
+	                             // and concurrent enumeration setup
+	                             // (set_composite_interface, set_hid_interface,
+	                             // and HUB_PASS/DEV_PASS in winusb_get_device_list)
 	struct {
 		char *path; // each interface needs a device interface path,
 		const struct windows_usb_api_backend *apib; // an API backend (multiple drivers support),
@@ -275,7 +285,7 @@ struct usbdk_device_handle_priv {
 	// Not currently used
 	char dummy;
 };
- 
+
 enum WINUSB_ZLP {
 	WINUSB_ZLP_UNSET = 0,
 	WINUSB_ZLP_OFF = 1,
@@ -320,6 +330,8 @@ struct windows_backend {
 	void (*exit)(struct libusb_context *ctx);
 	int (*get_device_list)(struct libusb_context *ctx,
 		struct discovered_devs **discdevs);
+	int (*get_device_string)(libusb_device *dev,
+		enum libusb_device_string_type string_type, char *data, int length);
 	int (*open)(struct libusb_device_handle *dev_handle);
 	void (*close)(struct libusb_device_handle *dev_handle);
 	int (*get_active_config_descriptor)(struct libusb_device *device,
@@ -342,6 +354,13 @@ struct windows_backend {
 	int (*cancel_transfer)(struct usbi_transfer *itransfer);
 	void (*clear_transfer_priv)(struct usbi_transfer *itransfer);
 	enum libusb_transfer_status (*copy_transfer_data)(struct usbi_transfer *itransfer, DWORD length);
+	int (*endpoint_supports_raw_io)(struct libusb_device_handle *dev_handle,
+		uint8_t endpoint);
+	int (*endpoint_set_raw_io)(struct libusb_device_handle *dev_handle,
+		uint8_t endpoint, int enable);
+	int (*get_max_raw_io_transfer_size)(
+                struct libusb_device_handle *dev_handle,
+		uint8_t endpoint);
 };
 
 struct windows_context_priv {

package/libusb/libusb/os/windows_hotplug.c

@@ -0,0 +1,321 @@
+/*
+ * windows hotplug backend for libusb 1.0
+ * Copyright © 2024 Sylvain Fasel <sylvain@sonatique.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+#include "threads_windows.h"
+
+#include "windows_common.h"
+#include "windows_hotplug.h"
+
+#include <stdio.h>
+#include <dbt.h>
+
+/* The Windows Hotplug system is a two steps process.
+ * 1. We create a hidden window and listen for DBT_DEVNODES_CHANGED, which Windows
+ *    broadcasts to all top-level windows whenever the device tree changes (no
+ *    registration required). Multiple rapid events (e.g. a hub with many children)
+ *    are coalesced via a short debounce timer so we only scan once the burst settles.
+ *    A maximum delay ceiling guarantees a scan fires within a bounded time even
+ *    during sustained bursts, preventing unbounded latency.
+ * 2. Upon timer expiry, we snapshot the current device list, run a full re-enumeration
+ *    via the Windows backend, then diff the result: newly found devices that have been
+ *    successfully initialized generate DEVICE_ARRIVED events; devices that were not
+ *    encountered by the re-enumeration (physically removed) generate DEVICE_LEFT events.
+ */
+
+#define HOTPLUG_DEBOUNCE_TIMER_ID       1
+#define HOTPLUG_DEBOUNCE_MS             10
+#define HOTPLUG_DEBOUNCE_MAX_DELAY_MS   100
+
+static ULONGLONG first_debounce_tick;
+static HWND windows_event_hwnd;
+static HANDLE windows_event_thread_handle;
+static DWORD WINAPI windows_event_thread_main(LPVOID lpParam);
+static LRESULT CALLBACK windows_proc_callback(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+#define log_error(operation) do { \
+	usbi_err(NULL, "%s failed with error: %s", operation, windows_error_str(0)); \
+} while (0)
+
+int windows_start_event_monitor(void)
+{
+	windows_event_thread_handle = CreateThread(
+		NULL, // Default security descriptor
+		0, // Default stack size
+		windows_event_thread_main,
+		NULL, // No parameters to pass to the thread
+		0, // Start immediately
+		NULL // No need to keep track of thread ID
+	);
+
+	if (windows_event_thread_handle == NULL)
+	{
+		log_error("CreateThread");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+int windows_stop_event_monitor(void)
+{
+	if (windows_event_hwnd == NULL)
+	{
+		return LIBUSB_SUCCESS;
+	}
+
+	if (!SUCCEEDED(SendMessage(windows_event_hwnd, WM_CLOSE, 0, 0)))
+	{
+		log_error("SendMessage");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	if (WaitForSingleObject(windows_event_thread_handle, INFINITE) != WAIT_OBJECT_0)
+	{
+		log_error("WaitForSingleObject");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	if (!CloseHandle(windows_event_thread_handle))
+	{
+		log_error("CloseHandle");
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return LIBUSB_SUCCESS;
+}
+
+static int windows_get_device_list(struct libusb_context *ctx)
+{
+	// note: context device list is protected by active_contexts_lock
+	return ((struct windows_context_priv *)usbi_get_context_priv(ctx))->backend->get_device_list(ctx, NULL);
+}
+
+void windows_initial_scan_devices(struct libusb_context *ctx)
+{
+	usbi_mutex_static_lock(&active_contexts_lock);
+
+	const int ret =  windows_get_device_list(ctx);
+	if (ret != LIBUSB_SUCCESS)
+	{
+		usbi_err(ctx, "hotplug failed to retrieve initial list with error: %s", libusb_error_name(ret));
+	}
+	usbi_mutex_static_unlock(&active_contexts_lock);
+}
+
+static void windows_refresh_device_list(struct libusb_context *ctx)
+{
+	struct libusb_device *dev, *next_dev;
+
+	// Step 1: clear seen_during_scan so the scan can mark which devices are still
+	// physically present, and set seen_before_scan so we can distinguish newly
+	// created devices (which start with seen_before_scan=false via calloc).
+	for_each_device_safe(ctx, dev, next_dev)
+	{
+		struct winusb_device_priv *priv = (struct winusb_device_priv *)usbi_get_device_priv(dev);
+		priv->seen_during_scan = false;
+		priv->seen_before_scan = true;
+	}
+
+	// Step 2: re-enumerate — winusb_get_device_list attaches newly-arrived devices
+	// and sets seen_during_scan=true for every device it physically encounters.
+	// seen_before_scan is untouched and will be left in default state (false) for newly created devices, allowing us to identify them in the next step.
+	const int ret = windows_get_device_list(ctx);
+	if (ret != LIBUSB_SUCCESS)
+	{
+		usbi_err(ctx, "hotplug failed to retrieve current list with error: %s", libusb_error_name(ret));
+		return;
+	}
+
+	// Step 3: diff old vs new.
+	for_each_device_safe(ctx, dev, next_dev)
+	{
+		struct winusb_device_priv *priv = (struct winusb_device_priv *)usbi_get_device_priv(dev);
+
+		if (!priv->seen_during_scan)
+		{
+			// Not encountered by the scan: device was physically removed.
+			if (priv->initialized)
+			{
+				usbi_disconnect_device(dev); // fires DEVICE_LEFT
+			}
+			else
+			{
+				usbi_detach_device(dev);
+				// No DEVICE_LEFT message is posted for uninitialized
+				// devices, so no message handler will drop the initial
+				// ref. We must drop it here to avoid a leak.
+				libusb_unref_device(dev);
+			}
+		}
+		else if (!priv->seen_before_scan)
+		{
+			if (priv->initialized)
+			{
+				usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
+			}
+		}
+	}
+}
+
+static void windows_refresh_device_list_for_all_ctx(void)
+{
+	usbi_mutex_static_lock(&active_contexts_lock);
+
+	struct libusb_context *ctx;
+	for_each_context(ctx)
+	{
+		windows_refresh_device_list(ctx);
+	}
+
+	usbi_mutex_static_unlock(&active_contexts_lock);
+}
+
+#define WND_CLASS_NAME TEXT("libusb-1.0-windows-hotplug")
+
+static bool init_wnd_class(void)
+{
+	WNDCLASS wndClass = { 0 };
+	wndClass.lpfnWndProc = windows_proc_callback;
+	wndClass.hInstance = GetModuleHandle(NULL);
+	wndClass.lpszClassName = WND_CLASS_NAME;
+
+	if (!RegisterClass(&wndClass))
+	{
+		log_error("event thread: RegisterClass");
+		return false;
+	}
+
+	return true;
+}
+
+static DWORD WINAPI windows_event_thread_main(LPVOID lpParam)
+{
+	UNUSED(lpParam);
+
+	usbi_dbg(NULL, "windows event thread entering");
+
+	if (!init_wnd_class())
+	{
+		return (DWORD)-1;
+	}
+
+	windows_event_hwnd = CreateWindow(
+		WND_CLASS_NAME,
+		TEXT(""),
+		0,
+		0, 0, 0, 0,
+		NULL, NULL,
+		GetModuleHandle(NULL),
+		NULL);
+
+	if (windows_event_hwnd == NULL)
+	{
+		log_error("event thread: CreateWindow");
+		return (DWORD)-1;
+	}
+
+	MSG msg;
+	BOOL ret_val;
+
+	while ((ret_val = GetMessage(&msg, windows_event_hwnd, 0, 0)) != 0)
+	{
+		if (ret_val == -1)
+		{
+			log_error("event thread: GetMessage");
+			break;
+		}
+
+		if (!SUCCEEDED(TranslateMessage(&msg)))
+		{
+			log_error("event thread: TranslateMessage");
+		}
+
+		if (!SUCCEEDED(DispatchMessage(&msg)))
+		{
+			log_error("event thread: DispatchMessage");
+		}
+	}
+
+	usbi_dbg(NULL, "windows event thread exiting");
+
+	return 0;
+}
+
+static LRESULT CALLBACK windows_proc_callback(
+	HWND hwnd,
+	UINT message,
+	WPARAM wParam,
+	LPARAM lParam)
+{
+	switch (message)
+	{
+	case WM_DEVICECHANGE:
+		if (wParam == DBT_DEVNODES_CHANGED)
+		{
+			if (first_debounce_tick == 0)
+			{
+				// First event in a new burst — record the time and start the debounce timer.
+				first_debounce_tick = GetTickCount64();
+				SetTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID, HOTPLUG_DEBOUNCE_MS, NULL);
+			}
+			else if (GetTickCount64() - first_debounce_tick >= HOTPLUG_DEBOUNCE_MAX_DELAY_MS)
+			{
+				// Maximum delay reached — force an immediate scan so devices
+				// are not invisible for the entire duration of a sustained burst.
+				KillTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID);
+				first_debounce_tick = 0;
+				windows_refresh_device_list_for_all_ctx();
+			}
+			else
+			{
+				// Still within the max-delay window — reset the debounce timer.
+				SetTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID, HOTPLUG_DEBOUNCE_MS, NULL);
+			}
+			return TRUE;
+		}
+		return DefWindowProc(hwnd, message, wParam, lParam);
+
+	case WM_TIMER:
+		if (wParam == HOTPLUG_DEBOUNCE_TIMER_ID)
+		{
+			KillTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID);
+			first_debounce_tick = 0;
+			windows_refresh_device_list_for_all_ctx();
+			return 0;
+		}
+		return DefWindowProc(hwnd, message, wParam, lParam);
+
+	case WM_CLOSE:
+		KillTimer(hwnd, HOTPLUG_DEBOUNCE_TIMER_ID);
+		first_debounce_tick = 0;
+		if (!DestroyWindow(hwnd))
+		{
+			log_error("DestroyWindow");
+		}
+		return 0;
+
+	case WM_DESTROY:
+		PostQuitMessage(0);
+		return 0;
+
+	default:
+		return DefWindowProc(hwnd, message, wParam, lParam);
+	}
+}

package/libusb/libusb/os/windows_hotplug.h

@@ -0,0 +1,28 @@
+/*
+ * windows hotplug backend for libusb 1.0
+ * Copyright © 2024 Sylvain Fasel <sylvain@sonatique.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef WINDOWS_HOTPLUG_H
+#define WINDOWS_HOTPLUG_H
+
+int windows_start_event_monitor(void);
+int windows_stop_event_monitor(void);
+
+void windows_initial_scan_devices(struct libusb_context *ctx);
+
+#endif

package/libusb/libusb/os/windows_usbdk.c

@@ -341,17 +341,21 @@ static int usbdk_get_device_list(struct libusb_context *ctx, struct discovered_d
 				libusb_unref_device(dev);
 				continue;
 			}
-		}
 
-		discdevs = discovered_devs_append(*_discdevs, dev);
-		libusb_unref_device(dev);
-		if (!discdevs) {
-			usbi_err(ctx, "cannot append new device to list");
-			r = LIBUSB_ERROR_NO_MEM;
-			goto func_exit;
+			usbi_connect_device(dev);
 		}
 
-		*_discdevs = discdevs;
+		if (_discdevs) {
+			discdevs = discovered_devs_append(*_discdevs, dev);
+			libusb_unref_device(dev);
+			if (!discdevs) {
+				usbi_err(ctx, "cannot append new device to list");
+				r = LIBUSB_ERROR_NO_MEM;
+				goto func_exit;
+			}
+
+			*_discdevs = discdevs;
+		}
 	}
 
 func_exit:
@@ -704,6 +708,7 @@ const struct windows_backend usbdk_backend = {
 	usbdk_init,
 	usbdk_exit,
 	usbdk_get_device_list,
+	NULL,  /* usbdk_get_device_string */
 	usbdk_open,
 	usbdk_close,
 	usbdk_get_active_config_descriptor,
@@ -721,4 +726,7 @@ const struct windows_backend usbdk_backend = {
 	NULL,	/* cancel_transfer */
 	usbdk_clear_transfer_priv,
 	usbdk_copy_transfer_data,
+	NULL,	/* endpoint_supports_raw_io */
+	NULL,	/* endpoint_set_raw_io */
+	NULL,	/* get_max_raw_io_transfer_size */
 };