usb 2.17.0 → 2.18.0

package/libusb/msvc/libusb_dll.vcxproj

@@ -30,6 +30,7 @@
     <ClCompile Include="..\libusb\os\events_windows.c" />
     <ClCompile Include="..\libusb\hotplug.c" />
     <ClCompile Include="..\libusb\io.c" />
+    <ClCompile Condition="'$(EnableWindowsHotplug)' == 'true'" Include="..\libusb\os\windows_hotplug.c" />
     <ClCompile Include="..\libusb\strerror.c" />
     <ClCompile Include="..\libusb\sync.c" />
     <ClCompile Include="..\libusb\os\threads_windows.c" />
@@ -38,6 +39,7 @@
     <ClCompile Include="..\libusb\os\windows_winusb.c" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Condition="'$(EnableWindowsHotplug)' == 'true'" Include="..\libusb\os\windows_hotplug.h" />
     <ClInclude Include=".\config.h" />
     <ClInclude Include="..\libusb\os\events_windows.h" />
     <ClInclude Include="..\libusb\libusb.h" />

package/libusb/msvc/libusb_static.vcxproj

@@ -24,6 +24,7 @@
     <ClCompile Include="..\libusb\os\events_windows.c" />
     <ClCompile Include="..\libusb\hotplug.c" />
     <ClCompile Include="..\libusb\io.c" />
+    <ClCompile Condition="'$(EnableWindowsHotplug)' == 'true'" Include="..\libusb\os\windows_hotplug.c" />
     <ClCompile Include="..\libusb\strerror.c" />
     <ClCompile Include="..\libusb\sync.c" />
     <ClCompile Include="..\libusb\os\threads_windows.c" />
@@ -32,6 +33,7 @@
     <ClCompile Include="..\libusb\os\windows_winusb.c" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Condition="'$(EnableWindowsHotplug)' == 'true'" Include="..\libusb\os\windows_hotplug.h" />
     <ClInclude Include=".\config.h" />
     <ClInclude Include="..\libusb\os\events_windows.h" />
     <ClInclude Include="..\libusb\libusb.h" />

package/libusb/msvc/xusb.vcxproj

@@ -17,7 +17,7 @@
   <ItemDefinitionGroup>
     <ClCompile>
       <!--VS2013 complains about while(0)-->
-      <DisableSpecificWarnings Condition="'$(PlatformToolsetVersion)'&lt;='120'">4127;%(DisableSpecificWarnings)</DisableSpecificWarnings>
+      <DisableSpecificWarnings Condition="'$(LibusbPlatformToolsetVersion)'&lt;='120'">4127;%(DisableSpecificWarnings)</DisableSpecificWarnings>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>

package/libusb/tests/Makefile.am

@@ -1,6 +1,15 @@
 AM_CPPFLAGS = -I$(top_srcdir)/libusb
 LDADD = ../libusb/libusb-1.0.la
-AM_LDFLAGS = -static
+
+if OS_HAIKU
+# Haiku backend includes C++ objects and some toolchains do not ship
+# static libstdc++. Keep tests dynamically linked to avoid static link failures.
+test_static_link_flag =
+else
+test_static_link_flag = -static
+endif
+
+AM_LDFLAGS = $(test_static_link_flag)
 
 stress_SOURCES = stress.c testlib.c
 stress_mt_SOURCES = stress_mt.c

package/libusb/tests/fuzz/fuzz_bos_descriptor.c

@@ -0,0 +1,49 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libusb.h>
+
+/* Fuzz the public BOS device-capability parsers.
+   We construct a valid BOS dev-cap header (3 bytes) + variable payload.
+   No hardware needed; ctx=NULL is fine. */
+
+int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (!data) return 0;
+
+  /* bLength is 3 (header) + payload; must fit in one byte. */
+  uint8_t payload_len = (size > 252) ? 252 : (uint8_t)size;  /* 255 - 3 = 252 */
+  size_t total_len = 3u + (size_t)payload_len;
+
+  /* Allocate header + payload for the flexible array member. */
+  struct libusb_bos_dev_capability_descriptor *devcap =
+      (struct libusb_bos_dev_capability_descriptor*)
+      malloc(sizeof(*devcap) + payload_len);
+  if (!devcap) return 0;
+
+  devcap->bLength         = (uint8_t)total_len;
+  devcap->bDescriptorType = LIBUSB_DT_DEVICE_CAPABILITY; /* 0x10 */
+  /* Copy fuzz bytes into the variable-length payload. */
+  if (payload_len) memcpy(devcap->dev_capability_data, data, payload_len);
+
+  /* 1) USB 2.0 Extension dev-cap */
+  devcap->bDevCapabilityType = LIBUSB_BT_USB_2_0_EXTENSION;
+  struct libusb_usb_2_0_extension_descriptor *d20 = NULL;
+  (void)libusb_get_usb_2_0_extension_descriptor(NULL, devcap, &d20);
+  libusb_free_usb_2_0_extension_descriptor(d20);
+
+  /* 2) SuperSpeed USB Device Capability dev-cap */
+  devcap->bDevCapabilityType = LIBUSB_BT_SS_USB_DEVICE_CAPABILITY;
+  struct libusb_ss_usb_device_capability_descriptor *dss = NULL;
+  (void)libusb_get_ss_usb_device_capability_descriptor(NULL, devcap, &dss);
+  libusb_free_ss_usb_device_capability_descriptor(dss);
+
+  /* 3) Container ID dev-cap */
+  devcap->bDevCapabilityType = LIBUSB_BT_CONTAINER_ID;
+  struct libusb_container_id_descriptor *dcid = NULL;
+  (void)libusb_get_container_id_descriptor(NULL, devcap, &dcid);
+  libusb_free_container_id_descriptor(dcid);
+
+  free(devcap);
+  return 0;
+}

package/libusb/tests/fuzz/fuzz_descriptor_parsers.c

@@ -0,0 +1,83 @@
+/* Fuzz the static descriptor parsers in libusb/descriptor.c.
+ *
+ * The relevant entry points (parse_configuration, parse_interface,
+ * parse_endpoint, parse_iad_array) all have file-local linkage, so we
+ * compile them into this fuzzer's translation unit by including the source
+ * file directly. The libusb_get_*() public APIs that wrap them require a
+ * libusb_device with a backend, which is more setup than a fuzz target
+ * needs. The unity-include keeps the fuzzer focused on parser logic only.
+ *
+ * Three small symbol stubs satisfy references that descriptor.c makes into
+ * other libusb translation units; none of those code paths are reachable
+ * from the parsers we exercise here.
+ *
+ * Built as part of the OSS-Fuzz integration; not exercised by the autotools
+ * test suite.
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ENABLE_LOGGING affects only printf-like macros we don't care about. */
+#define ENABLE_LOGGING 0
+
+#include "config.h"
+#include "libusbi.h"
+#include "../../libusb/descriptor.c"
+
+/* Stubs for symbols that descriptor.c references but the parsers we fuzz
+ * never reach (logging sink, backend dispatch, control-transfer wrapper). */
+const struct usbi_os_backend usbi_backend = {0};
+void usbi_log(struct libusb_context *ctx, enum libusb_log_level level,
+              const char *function, const char *format, ...) {
+    (void)ctx; (void)level; (void)function; (void)format;
+}
+int libusb_control_transfer(libusb_device_handle *dev_handle,
+                            uint8_t bmRequestType, uint8_t bRequest,
+                            uint16_t wValue, uint16_t wIndex,
+                            unsigned char *data, uint16_t wLength,
+                            unsigned int timeout) {
+    (void)dev_handle; (void)bmRequestType; (void)bRequest; (void)wValue;
+    (void)wIndex; (void)data; (void)wLength; (void)timeout;
+    return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    /* The limit of 8192 is comfortably above practical cases and
+     * still keeping libFuzzer iterations fast and the corpus small */
+    if (size < LIBUSB_DT_CONFIG_SIZE || size > 8192)
+        return 0;
+
+    /* Every call gets a fresh exact-size copy so any byte read past the
+     * end is caught by ASan. The fuzzer must not observe state between
+     * iterations. */
+    uint8_t *buf;
+
+    /* (1) parse_configuration -> parse_interface -> parse_endpoint */
+    buf = malloc(size);
+    if (!buf) return 0;
+    memcpy(buf, data, size);
+    {
+        struct libusb_config_descriptor cfg;
+        memset(&cfg, 0, sizeof(cfg));
+        if (parse_configuration(NULL, &cfg, buf, (int)size) >= 0)
+            clear_configuration(&cfg);
+    }
+    free(buf);
+
+    /* (2) parse_iad_array */
+    buf = malloc(size);
+    if (!buf) return 0;
+    memcpy(buf, data, size);
+    {
+        struct libusb_interface_association_descriptor_array iad;
+        memset(&iad, 0, sizeof(iad));
+        if (parse_iad_array(NULL, &iad, buf, (int)size) == LIBUSB_SUCCESS)
+            free((void *)iad.iad);
+    }
+    free(buf);
+
+    return 0;
+}

package/libusb/tests/stress_mt.c

@@ -230,7 +230,8 @@ static int test_multi_init(int enumerate)
 				tinfo[t].number,
 				tinfo[t].iteration,
 				libusb_error_name(tinfo[t].err));
-		} else if (enumerate) {
+		}
+		if (enumerate) {
 			if (t > 0 && tinfo[t].devcount != last_devcount) {
 				devcount_mismatch++;
 				printf("Device count mismatch: Thread %d discovered %ld devices instead of %ld\n",

package/libusb/tests/webusb-test-shim/index.js

@@ -5,8 +5,9 @@
 
 const { WebUSB } = require('usb');
 
-globalThis.navigator = {
-  usb: new WebUSB({
-    allowAllDevices: true
-  })
-};
+// Node.js 21 introduced a global `navigator` object, so assign an empty one only if it's not present yet.
+globalThis.navigator ??= {};
+
+navigator.usb = new WebUSB({
+  allowAllDevices: true
+});

package/libusb.gypi

@@ -129,6 +129,8 @@
             'libusb/libusb/os/threads_windows.h',
             'libusb/libusb/os/windows_common.c',
             'libusb/libusb/os/windows_common.h',
+            'libusb/libusb/os/windows_hotplug.c',
+            'libusb/libusb/os/windows_hotplug.h',
             'libusb/libusb/os/windows_usbdk.c',
             'libusb/libusb/os/windows_usbdk.h',
             'libusb/libusb/os/windows_winusb.c',
@@ -141,6 +143,9 @@
           'include_dirs': [
             'libusb/msvc',
           ],
+          'defines': [
+            'LIBUSB_WINDOWS_HOTPLUG=1',
+          ],
           'msvs_disabled_warnings': [ 4267 ],
           'msvs_settings': {
               'VCCLCompilerTool': {

package/package.json

@@ -2,7 +2,7 @@
   "name": "usb",
   "description": "Library to access USB devices",
   "license": "MIT",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "main": "dist/index.js",
   "engines": {
     "node": ">=12.22.0 <13.0 || >=14.17.0"

package/src/{hotplug/libusb.cc → hotplug.cc}

@@ -14,10 +14,9 @@ int LIBUSB_CALL hotplug_callback(libusb_context* ctx, libusb_device* device, lib
 }
 
 class HotPlugManagerLibUsb: public HotPlugManager {
-    int supportedHotplugEvents() {
+    bool supportedHotplugEvents() {
         int res = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
-
-        return res > 0 ? HOTPLUG_SUPPORTS_DEVICES : HOTPLUG_SUPPORTS_NONE;
+        return res > 0;
     }
 
     void enableHotplug(const Napi::Env& env, ModuleData* instanceData) {

package/src/{hotplug/hotplug.h → hotplug.h}

@@ -1,17 +1,13 @@
 #ifndef _USB_HOTPLUG_H
 #define _USB_HOTPLUG_H
 
-#include "../node_usb.h"
-
-#define HOTPLUG_SUPPORTS_NONE 0
-#define HOTPLUG_SUPPORTS_DEVICES 1
-#define HOTPLUG_SUPPORTS_IDS 2
+#include "node_usb.h"
 
 class HotPlugManager {
 public:
     static std::unique_ptr<HotPlugManager> create();
 
-    virtual int supportedHotplugEvents() = 0;
+    virtual bool supportedHotplugEvents() = 0;
 
     virtual void enableHotplug(const Napi::Env& env, ModuleData* instanceData) = 0;
     virtual void disableHotplug(const Napi::Env& env, ModuleData* instanceData) = 0;

package/src/node_usb.cc

@@ -1,6 +1,6 @@
 #include "node_usb.h"
 #include "thread_name.h"
-#include "hotplug/hotplug.h"
+#include "hotplug.h"
 
 Napi::Value SetDebugLevel(const Napi::CallbackInfo& info);
 Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info);
@@ -130,8 +130,8 @@ Napi::Value SupportedHotplugEvents(const Napi::CallbackInfo& info) {
     Napi::HandleScope scope(env);
     ModuleData* instanceData = env.GetInstanceData<ModuleData>();
 
-    int res = instanceData->hotplugManager->supportedHotplugEvents();
-    return Napi::Number::New(env, res);
+    bool res = instanceData->hotplugManager->supportedHotplugEvents();
+    return Napi::Boolean::New(env, res);
 }
 
 Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info) {

package/test/usb.coffee

@@ -164,8 +164,8 @@ describe 'Device', ->
                     done()
 
             it 'times out', (done) ->
-                iface.endpoints[2].timeout = 20
-                iface.endpoints[2].transfer 64, (e, d) ->
+                iface.endpoints[4].timeout = 20
+                iface.endpoints[4].transfer 64, (e, d) ->
                     assert.equal e.errno, usb.LIBUSB_TRANSFER_TIMED_OUT
                     done()
 
@@ -228,8 +228,8 @@ describe 'Device', ->
                     done()
 
             it 'times out', (done) ->
-                iface.endpoints[3].timeout = 20
-                iface.endpoints[3].transfer [1,2,3,4], (e) ->
+                iface.endpoints[5].timeout = 20
+                iface.endpoints[5].transfer [1,2,3,4], (e) ->
                     assert.equal e.errno, usb.LIBUSB_TRANSFER_TIMED_OUT
                     done()
 

package/test/webusb.coffee

@@ -182,7 +182,8 @@ describe 'Throwing Transfers', ->
 
 describe 'Transfers', ->
     device = null
-    b = Uint8Array.from([0x30...0x40]).buffer
+    b1 = Uint8Array.from([0x30...0x40]).buffer
+    b2 = Uint8Array.from([0x32...0x42]).buffer
 
     before ->
         device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
@@ -191,37 +192,46 @@ describe 'Transfers', ->
 
     it 'should control transfer OUT', ->
         transferResult = await device.controlTransferOut({
-            requestType: 'device',
-            recipient: 'vendor',
+            requestType: 'vendor',
+            recipient: 'device',
             request: 0x81,
             value: 0,
             index: 0
-        }, b)
+        }, b1)
 
         assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.bytesWritten, b.byteLength)
+        assert.equal(transferResult.bytesWritten, b1.byteLength)
 
     it 'should control transfer IN', ->
         transferResult = await device.controlTransferIn({
-            requestType: 'device',
-            recipient: 'vendor',
+            requestType: 'vendor',
+            recipient: 'device',
             request: 0x81,
             value: 0,
             index: 0
         }, 128)
 
         assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.data.buffer.toString(), b.toString())
+        assert.equal(transferResult.data.byteLength, b1.byteLength)
+        resultBuffer = Buffer.from(transferResult.data.buffer, transferResult.data.byteOffset, transferResult.data.byteLength);
+        expectedBuffer = Buffer.from(b1, 0, b1.byteLength);
+        assert(resultBuffer.equals(expectedBuffer));
 
     it 'should transfer OUT', ->
-        transferResult = await device.transferOut(2, b)
+        transferResult = await device.transferOut(4, b2)
+
         assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.bytesWritten, b.byteLength)
+        assert.equal(transferResult.bytesWritten, b2.byteLength)
 
     it 'should transfer IN', ->
-        transferResult = await device.transferIn(1, 64)
+        transferResult = await device.transferIn(3, b2.byteLength)
+
         assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.data.byteLength, 64)
+        assert.equal(transferResult.data.byteLength, b2.byteLength)
 
+        resultBuffer = Buffer.from(transferResult.data.buffer, transferResult.data.byteOffset, transferResult.data.byteLength);
+        expectedBuffer = Buffer.from(b2, 0, b2.byteLength);
+        assert(resultBuffer.equals(expectedBuffer));
+    
     after ->
         device.close()

package/src/hotplug/windows.cc

@@ -1,168 +0,0 @@
-#include "hotplug.h"
-
-// Include Windows headers
-#include <windows.h>
-#include <initguid.h>
-#include <Cfgmgr32.h>
-#include <usbiodef.h>
-
-#include <locale>
-#include <codecvt>
-#include <cwctype>
-
-#define VID_TAG L"VID_"
-#define PID_TAG L"PID_"
-
-struct HotPlug {
-    int vid;
-    int pid;
-    CM_NOTIFY_ACTION event;
-    Napi::ObjectReference* hotplugThis;
-};
-
-void extractVidPid(wchar_t *buf, int *vid, int *pid)
-{
-    // Example input: \\?\USB#VID_0FD9&PID_0060#000000000000#{a5dcbf10-6530-11d2-901f-00c04fb951ed}
-
-    *vid = 0;
-    *pid = 0;
-
-    if (buf == NULL)
-    {
-        return;
-    }
-    
-    auto string = std::wstring(buf);
-    std::transform(string.begin(), string.end(), string.begin(), std::towupper);
-
-    wchar_t* temp = new wchar_t[5];
-    temp[4] = L'\0';
-
-    const wchar_t *vidStr = wcsstr(string.data(), VID_TAG);
-    const wchar_t *pidStr = wcsstr(string.data(), PID_TAG);
-
-    if (vidStr != nullptr)
-    {
-        memcpy(temp, vidStr + wcslen(VID_TAG), 4 * sizeof(wchar_t));
-        *vid = wcstol(temp, NULL, 16);
-    }
-
-    if (pidStr != nullptr)
-    {
-        memcpy(temp, pidStr + wcslen(PID_TAG), 4 * sizeof(wchar_t));
-        *pid = wcstol(temp, NULL, 16);
-    }
-}
-
-DWORD WINAPI MyCMInterfaceNotification(HCMNOTIFICATION hNotify, PVOID Context, CM_NOTIFY_ACTION Action, PCM_NOTIFY_EVENT_DATA EventData, DWORD EventDataSize)
-{
-    switch (Action)
-    {
-    case CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL:
-    case CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL:
-    {
-        ModuleData* instanceData = (ModuleData*)Context;
-
-        int vid = 0;
-        int pid = 0;
-        extractVidPid(EventData->u.DeviceInterface.SymbolicLink, &vid, &pid);
-
-        instanceData->hotplugQueue.post(new HotPlug {vid, pid, Action, &instanceData->hotplugThis});
-        break;
-    }
-    default:
-        break;
-    }
-    return ERROR_SUCCESS;
-}
-
-class HotPlugManagerWindows : public HotPlugManager
-{
-public:
-    HotPlugManagerWindows()
-    : hcm(nullptr)
-    {
-        cmNotifyFilter = { 0 };
-        cmNotifyFilter.cbSize = sizeof(cmNotifyFilter);
-        cmNotifyFilter.Flags = 0;
-        cmNotifyFilter.FilterType = CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE;
-        cmNotifyFilter.u.DeviceInterface.ClassGuid = GUID_DEVINTERFACE_USB_DEVICE;
-    }
-    
-    int supportedHotplugEvents()
-    {
-        return HOTPLUG_SUPPORTS_IDS;
-    }
-
-    void enableHotplug(const Napi::Env &env, ModuleData *instanceData)
-    {
-        if (isRunning)
-        {
-            return;
-        }
-
-        isRunning = true;
-    
-        auto res = CM_Register_Notification(&cmNotifyFilter, (PVOID)instanceData, (PCM_NOTIFY_CALLBACK)&MyCMInterfaceNotification, &hcm);
-        if (res != CR_SUCCESS)
-        {
-            isRunning = false;
-            THROW_ERROR("RegisterNotification failed")
-        }
-    }
-
-    void disableHotplug(const Napi::Env &env, ModuleData *instanceData)
-    {
-        if (isRunning)
-        {
-            isRunning = false;
-
-            if (hcm) {
-                CM_Unregister_Notification(hcm);
-                hcm = nullptr;
-            }
-        }
-    }
-
-private:
-    std::atomic<bool> isRunning = {false};
-    HCMNOTIFICATION hcm;
-    CM_NOTIFY_FILTER cmNotifyFilter;
-};
-
-std::unique_ptr<HotPlugManager> HotPlugManager::create()
-{
-    return std::make_unique<HotPlugManagerWindows>();
-}
-
-void handleHotplug(HotPlug* info) {
-    Napi::ObjectReference* hotplugThis = info->hotplugThis;
-    Napi::Env env = hotplugThis->Env();
-    Napi::HandleScope scope(env);
-
-    int vid = info->vid;
-    int pid = info->pid;
-    Napi::Object v8VidPid = Napi::Object::New(env);
-    v8VidPid.Set("idVendor", Napi::Number::New(env, vid));
-    v8VidPid.Set("idProduct", Napi::Number::New(env, pid));
-    CM_NOTIFY_ACTION event = info->event;
-    delete info;
-
-    DEBUG_LOG("HandleHotplug %i %i %i", vid, pid, event);
-
-    Napi::String eventName;
-    if (CM_NOTIFY_ACTION_DEVICEINTERFACEARRIVAL == event) {
-        DEBUG_LOG("Device arrived");
-        eventName = Napi::String::New(env, "attachIds");
-
-    } else if (CM_NOTIFY_ACTION_DEVICEINTERFACEREMOVAL == event) {
-        DEBUG_LOG("Device left");
-        eventName = Napi::String::New(env, "detachIds");
-
-    } else {
-        DEBUG_LOG("Unhandled hotplug event %d\n", event);
-        return;
-    }
-    
-    hotplugThis->Get("emit").As<Napi::Function>().MakeCallback(hotplugThis->Value(), { eventName, v8VidPid });
-}