usb 2.4.1 → 2.4.2

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [2.4.2] - 2022-05-27
+
+### Fixed
+- Fixed multiple events with device detection on Windows - [`512`](https://github.com/node-usb/node-usb/pull/512) ([Alba Mendez](https://github.com/mildsunrise))
+
 ## [2.4.1] - 2022-05-07
 
 ### Fixed

package/binding.gyp

@@ -19,6 +19,7 @@
         './src/node_usb.cc',
         './src/device.cc',
         './src/transfer.cc',
+        './src/thread_name.cc',
       ],
       'cflags_cc': [
         '-std=c++14'

package/package.json

@@ -2,7 +2,7 @@
   "name": "usb",
   "description": "Library to access USB devices",
   "license": "MIT",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "main": "dist/index.js",
   "engines": {
     "node": ">=10.20.0 <11.x || >=12.17.0 <13.0 || >=14.0.0"

package/src/device.cc

@@ -14,7 +14,7 @@ Device::Device(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Device>(info),
 	device = info[0].As<Napi::External<libusb_device>>().Data();
 	libusb_ref_device(device);
 
-	std::map<libusb_device*, Device*> byPtr = env.GetInstanceData<ModuleData>()->byPtr;
+	std::map<libusb_device*, Device*>& byPtr = env.GetInstanceData<ModuleData>()->byPtr;
 	byPtr[device] = this;
 
 	DEBUG_LOG("Created device %p", this);
@@ -25,7 +25,7 @@ Device::~Device() {
 	DEBUG_LOG("Freed device %p", this);
 
 	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-	std::map<libusb_device*, Device*> byPtr = instanceData->byPtr;
+	std::map<libusb_device*, Device*>& byPtr = instanceData->byPtr;
 
 	auto it = byPtr.find(device);
 	if (it != byPtr.end() && it->second == this)
@@ -38,7 +38,7 @@ Device::~Device() {
 // or create a new one and add it to the map.
 Napi::Object Device::get(Napi::Env env, libusb_device* dev) {
 	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-	std::map<libusb_device*, Device*> byPtr = instanceData->byPtr;
+	std::map<libusb_device*, Device*>& byPtr = instanceData->byPtr;
 
 	auto it = byPtr.find(dev);
 	if (it != byPtr.end()) {

package/src/node_usb.cc

@@ -1,4 +1,5 @@
 #include "node_usb.h"
+#include "thread_name.h"
 
 Napi::Value SetDebugLevel(const Napi::CallbackInfo& info);
 Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info);
@@ -42,6 +43,7 @@ void handleHotplug(HotPlug* info){
 }
 
 void USBThreadFn(ModuleData* instanceData) {
+	SetThreadName("node-usb events");
 	libusb_context* usb_context = instanceData->usb_context;
 
 	while(true) {

package/src/thread_name.cc

@@ -0,0 +1,79 @@
+// Definition of a SetThreadName function with an emphasis in "portability",
+// meaning we prefer cautiously failing over creating build errors (or crashes)
+// on exotic platforms. To do this, we only include/link against very
+// few & widely available symbols.
+#include "thread_name.h"
+
+#if defined(__linux__)
+
+    // For Linux use the prctl API directly. prctl symbol
+    // should be available under any libc.
+    #include <sys/prctl.h>
+
+    // Define here to avoid relying on kernel headers being present
+    #define PR_SET_NAME    15		/* Set process name */
+
+    bool SetThreadName(const char* name) {
+        return prctl(PR_SET_NAME, name, 0, 0, 0) >= 0;
+    }
+
+#elif defined(__APPLE__)
+
+    // For MacOS use the dynamic linker because I don't
+    // want to take any risks
+    #include <dlfcn.h>
+
+    extern "C" typedef int (*SetNameFn)(const char*);
+
+    bool SetThreadName(const char* name) {
+        auto pthread_setname_np = reinterpret_cast<SetNameFn>(
+            dlsym(RTLD_DEFAULT, "pthread_setname_np"));
+        if (pthread_setname_np == nullptr)
+            return false;
+        return pthread_setname_np(name) == 0;
+    }
+
+#elif defined(_WIN32)
+
+    // For Windows, we use the new SetThreadDescription API which
+    // is only available in newish versions. To avoid taking any
+    // risks (and because on certain versions it's the only
+    // option to access the API), we use the dynamic linker
+    #include <windows.h>
+
+    extern "C" typedef HRESULT (WINAPI *SetThreadDescriptionFn)(HANDLE, PCWSTR);
+
+    static SetThreadDescriptionFn RetrieveSymbol(const char* objectName) {
+        auto mod = GetModuleHandleA(objectName);
+        if (mod == nullptr) return nullptr;
+        auto symbol = GetProcAddress(mod, "SetThreadDescription");
+        return reinterpret_cast<SetThreadDescriptionFn>(symbol);
+    }
+
+    #include <locale>
+    #include <codecvt>
+    #include <string>
+
+    bool SetThreadName(const char* name) {
+        auto SetThreadDescription = RetrieveSymbol("Kernel32.dll");
+        // apparently, MSDN is wrong and the symbol is defined in
+        // KernelBase.dll, so try that too
+        if (SetThreadDescription == nullptr)
+            SetThreadDescription = RetrieveSymbol("KernelBase.dll");
+
+        if (SetThreadDescription == nullptr) return false;
+
+        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+        std::wstring wide_name = converter.from_bytes(name);
+
+        auto result = SetThreadDescription(GetCurrentThread(), wide_name.c_str());
+        return SUCCEEDED(result);
+    }
+
+#else
+
+    bool SetThreadName(const char* name) {
+        return false;
+    }
+
+#endif

package/src/thread_name.h

@@ -0,0 +1,11 @@
+/**
+ * Sets the name of the calling thread to `name`, which is
+ * a NUL terminated UTF-8 string. Returns true if success,
+ * false if error or unsupported platform.
+ *
+ * Since this is an OS-dependent operation, the requirements
+ * of `name` may vary depending on platform. For example on
+ * Linux, the maximum length (excluding the terminator) is
+ * 16 bytes, and UTF-8 isn't strictly required (only conventional).
+ */
+bool SetThreadName(const char* name);