Merge remote-tracking branch 'libusb/master'

Author: KritzelKratzel

.github/workflows/android.yml

@@ -0,0 +1,55 @@
+name: Android
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        abi: [arm64-v8a, armeabi-v7a, x86_64]
+        api: [21]
+    env:
+      ANDROID_ABI: ${{ matrix.abi }}
+      ANDROID_API: ${{ matrix.api }}
+      NDK_OUT_DIR: ${{ github.workspace }}/out/${{ matrix.abi }}
+      NDK_LIBS_DIR: ${{ github.workspace }}/libs/${{ matrix.abi }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Show ANDROID_NDK_ROOT
+        run: |
+          echo "ANDROID_NDK_ROOT=${ANDROID_NDK_ROOT}"
+          test -d "${ANDROID_NDK_ROOT}" || (echo "ANDROID_NDK_ROOT not set or invalid" && exit 1)
+
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt install -y file
+
+      - name: Build with ndk-build
+        working-directory: android/jni
+        run: |
+          mkdir -p "${NDK_OUT_DIR}" "${NDK_LIBS_DIR}"
+          "${ANDROID_NDK_ROOT}/ndk-build" -j \
+            APP_ABI="${ANDROID_ABI}" \
+            APP_PLATFORM="android-${ANDROID_API}" \
+            NDK_OUT="${NDK_OUT_DIR}" \
+            NDK_LIBS_OUT="${NDK_LIBS_DIR}"
+
+      - name: Show outputs
+        run: |
+          set -euxo pipefail
+          find "${NDK_LIBS_DIR}" -maxdepth 2 -type f -print0 | xargs -0 ls -lh || true
+          file "${NDK_LIBS_DIR}/"* || true
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: libusb-android-${{ matrix.abi }}-api${{ matrix.api }}
+          path: |
+            libs/${{ matrix.abi }}/
+          if-no-files-found: error

.github/workflows/windows.yml

@@ -31,7 +31,19 @@ jobs:
 
       - name: Setup MSBuild
         uses: microsoft/setup-msbuild@v1.3
-        
+
       - name: Build solution
         run: |
           msbuild msvc/libusb.sln /m -property:Configuration=${{ matrix.configuration }} -property:Platform=${{ matrix.architecture }}
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-${{ matrix.os }}-${{ matrix.configuration }}-${{ matrix.architecture }}
+          path: |
+            build/**/*.exe
+            build/**/dll/libusb-1.0.dll
+            build/**/dll/libusb-1.0.lib
+            build/**/dll/libusb-1.0.exp
+            build/**/dll/libusb-1.0.pdb
+            build/**/lib/libusb-1.0.lib

libusb/os/haiku_usb_raw.cpp

@@ -186,6 +186,7 @@ const struct usbi_os_backend usbi_backend = {
 	/*.exit =*/ haiku_exit,
 	/*.set_option =*/ NULL,
 	/*.get_device_list =*/ NULL,
+	/*.get_device_string =*/ NULL,
 	/*.hotplug_poll =*/ NULL,
 	/*.wrap_sys_device =*/ NULL,
 	/*.open =*/ haiku_open,
@@ -214,6 +215,9 @@ const struct usbi_os_backend usbi_backend = {
 	/*.kernel_driver_active =*/ NULL,
 	/*.detach_kernel_driver =*/ NULL,
 	/*.attach_kernel_driver =*/ NULL,
+	/*.endpoint_supports_raw_io =*/ NULL,
+	/*.endpoint_set_raw_io =*/ NULL,
+	/*.get_max_raw_io_transfer_size =*/ NULL,
 
 	/*.destroy_device =*/ NULL,
 

libusb/os/windows_common.c

@@ -862,8 +862,17 @@ 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;
 
-	if (GetOverlappedResult(transfer_priv->handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
+	/*
+	 * 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_handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
 		result = NO_ERROR;
 	else
 		result = GetLastError();
@@ -905,7 +914,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);

libusb/os/windows_common.h

@@ -242,6 +242,10 @@ 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;
 	uint8_t depth; // distance to HCD
@@ -275,7 +279,7 @@ struct usbdk_device_handle_priv {
 	// Not currently used
 	char dummy;
 };
- 
+
 enum WINUSB_ZLP {
 	WINUSB_ZLP_UNSET = 0,
 	WINUSB_ZLP_OFF = 1,

libusb/os/windows_hotplug.c

@@ -25,16 +25,25 @@
 
 #include <stdio.h>
 #include <dbt.h>
-#include <usbiodef.h>
-
-/* The Windows Hotplug system is a three steps process.
- * 1. We create a monitor on GUID_DEVINTERFACE_USB_DEVICE via a hidden window.
- * 2. Upon notification of an event, we run the current windows backend to get
- *    the list of all devices.
- * 3. We use PDEV_BROADCAST_DEVICEINTERFACE->dbcc_name for finding device object
- *    in this list and generate LEFT or ARRIVED events libusb client via hotplug callbacks
+
+/* 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);
@@ -110,52 +119,65 @@ void windows_initial_scan_devices(struct libusb_context *ctx)
 	usbi_mutex_static_unlock(&active_contexts_lock);
 }
 
-static void windows_refresh_device_list(struct libusb_context *ctx, const bool device_arrived, const char* device_name)
+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;
 	}
 
-	struct libusb_device *dev, *next_dev;
-
+	// Step 3: diff old vs new.
 	for_each_device_safe(ctx, dev, next_dev)
 	{
-		struct winusb_device_priv* priv = usbi_get_device_priv(dev);
-
-		if(priv->path == NULL || _stricmp(priv->path, device_name) != 0)
-		{
-			continue;
-		}
+		struct winusb_device_priv *priv = (struct winusb_device_priv *)usbi_get_device_priv(dev);
 
-		if(device_arrived)
-		{
-			usbi_hotplug_notification(ctx, dev, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
-		}
-		else
+		if (!priv->seen_during_scan)
 		{
+			// Not encountered by the scan: device was physically removed.
 			if (priv->initialized)
 			{
-				usbi_disconnect_device(dev);
+				usbi_disconnect_device(dev); // fires DEVICE_LEFT
 			}
 			else
 			{
 				usbi_detach_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(const bool device_arrived, const char* device_name)
+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, device_arrived, device_name);
+		windows_refresh_device_list(ctx);
 	}
 
 	usbi_mutex_static_unlock(&active_contexts_lock);
@@ -232,107 +254,53 @@ static DWORD WINAPI windows_event_thread_main(LPVOID lpParam)
 	return 0;
 }
 
-static bool register_device_interface_to_window_handle(
-	IN GUID interface_class_guid,
-	IN HWND hwnd,
-	OUT HDEVNOTIFY* device_notify_handle)
-{
-	DEV_BROADCAST_DEVICEINTERFACE notificationFilter = { 0 };
-	notificationFilter.dbcc_size = sizeof(notificationFilter);
-	notificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
-	notificationFilter.dbcc_classguid = interface_class_guid;
-
-	*device_notify_handle = RegisterDeviceNotification(
-		hwnd,
-		&notificationFilter,
-		DEVICE_NOTIFY_WINDOW_HANDLE
-	);
-
-	if (*device_notify_handle == NULL)
-	{
-		log_error("register_device_interface_to_window_handle");
-		return false;
-	}
-
-	return true;
-}
-
 static LRESULT CALLBACK windows_proc_callback(
 	HWND hwnd,
 	UINT message,
 	WPARAM wParam,
 	LPARAM lParam)
 {
-	UNUSED(lParam);
-
-	static HDEVNOTIFY device_notify_handle;
-
 	switch (message)
 	{
-	case WM_CREATE:
-		if (!register_device_interface_to_window_handle(
-			GUID_DEVINTERFACE_USB_DEVICE,
-			hwnd,
-			&device_notify_handle))
-		{
-			return -1;
-		}
-		return 0;
-
 	case WM_DEVICECHANGE:
-		switch (wParam)
+		if (wParam == DBT_DEVNODES_CHANGED)
 		{
-		case DBT_DEVICEARRIVAL:
-		case DBT_DEVICEREMOVECOMPLETE:
-			if (((PDEV_BROADCAST_HDR)lParam)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
+			if (first_debounce_tick == 0)
 			{
-#ifdef UNICODE
-				char* device_name = NULL;
-				const WCHAR* w_dbcc_name = ((PDEV_BROADCAST_DEVICEINTERFACE)lParam)->dbcc_name;
-
-				const int len = WideCharToMultiByte(CP_UTF8, 0, w_dbcc_name, -1, NULL, 0, NULL, NULL);
-			    if (len == 0)
-				{
-			        log_error("Conversion length calculation failed for ((PDEV_BROADCAST_DEVICEINTERFACE)lParam)->dbcc_name conversion from wchar to char");
-			    }
-				else
-				{
-					device_name = (char *)malloc(len);
-				    if (device_name == NULL)
-					{
-				        log_error("Memory allocation failed for ((PDEV_BROADCAST_DEVICEINTERFACE)lParam)->dbcc_name conversion from wchar to char");
-				    }
-					else
-					{
-					    const int result = WideCharToMultiByte(CP_UTF8, 0, w_dbcc_name, -1, device_name, len, NULL, NULL);
-					    if (result == 0)
-						{
-					        log_error("Conversion failed for ((PDEV_BROADCAST_DEVICEINTERFACE)lParam)->dbcc_name conversion from wchar to char");
-					        free(device_name);
-							device_name = NULL;
-					    }
-					}
-    			}
-#else
-				const char* device_name = ((PDEV_BROADCAST_DEVICEINTERFACE)lParam)->dbcc_name;
-#endif
-
-				windows_refresh_device_list_for_all_ctx(wParam == DBT_DEVICEARRIVAL ? true : false, device_name);
-
-#ifdef UNICODE
-				free(device_name);
-#endif
-				return TRUE;
+				// 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);
 			}
-			break;
+			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 BROADCAST_QUERY_DENY;
+		return DefWindowProc(hwnd, message, wParam, lParam);
 
-	case WM_CLOSE:
-		if (!UnregisterDeviceNotification(device_notify_handle))
+	case WM_TIMER:
+		if (wParam == HOTPLUG_DEBOUNCE_TIMER_ID)
 		{
-			log_error("UnregisterDeviceNotification");
+			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");