usb 2.4.2 → 2.5.1

package/src/helpers.h

@@ -10,55 +10,55 @@
 const napi_property_attributes CONST_PROP = static_cast<napi_property_attributes>(napi_enumerable | napi_configurable);
 
 #define ENTER_CONSTRUCTOR(MIN_ARGS) \
-	Napi::HandleScope scope(env);              \
-	if (!info.IsConstructCall()) throw Napi::Error::New(env, "Must be called with `new`!"); \
-	CHECK_N_ARGS(MIN_ARGS);
+    Napi::HandleScope scope(env);              \
+    if (!info.IsConstructCall()) throw Napi::Error::New(env, "Must be called with `new`!"); \
+    CHECK_N_ARGS(MIN_ARGS);
 
 #define ENTER_CONSTRUCTOR_POINTER(CLASS, MIN_ARGS) \
-	ENTER_CONSTRUCTOR(MIN_ARGS)                    \
-	if (!info.Length() || !info[0].IsExternal()){ \
-		throw Napi::Error::New(env, "This type cannot be created directly!"); \
-	}                                                \
-	auto self = this;
+    ENTER_CONSTRUCTOR(MIN_ARGS)                    \
+    if (!info.Length() || !info[0].IsExternal()){ \
+        throw Napi::Error::New(env, "This type cannot be created directly!"); \
+    }                                                \
+    auto self = this;
 
 #define ENTER_METHOD(CLASS, MIN_ARGS) \
-	Napi::Env env = info.Env(); \
-	Napi::HandleScope scope(env);                \
-	CHECK_N_ARGS(MIN_ARGS);           \
-	auto self = this;
+    Napi::Env env = info.Env(); \
+    Napi::HandleScope scope(env);                \
+    CHECK_N_ARGS(MIN_ARGS);           \
+    auto self = this;
 
 #define ENTER_ACCESSOR(CLASS) \
-		Napi::HandleScope scope(env);                \
-		auto self = info.Holder().Unwrap<CLASS>();
+        Napi::HandleScope scope(env);                \
+        auto self = info.Holder().Unwrap<CLASS>();
 
 #define UNWRAP_ARG(CLASS, NAME, ARGNO)     \
-	if (!info[ARGNO].IsObject())          \
-		THROW_BAD_ARGS("Parameter " #NAME " is not an object"); \
-	auto NAME = Napi::ObjectWrap<CLASS>::Unwrap(info[ARGNO].As<Napi::Object>()); \
-	if (!NAME)                             \
-		THROW_BAD_ARGS("Parameter " #NAME " (" #ARGNO ") is of incorrect type");
+    if (!info[ARGNO].IsObject())          \
+        THROW_BAD_ARGS("Parameter " #NAME " is not an object"); \
+    auto NAME = Napi::ObjectWrap<CLASS>::Unwrap(info[ARGNO].As<Napi::Object>()); \
+    if (!NAME)                             \
+        THROW_BAD_ARGS("Parameter " #NAME " (" #ARGNO ") is of incorrect type");
 
 #define STRING_ARG(NAME, N) \
-	if (info.Length() > N){ \
-		if (!info[N].IsString()) \
-			THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be string"); \
-		NAME = *String::Utf8Value(info[N].ToString()); \
-	}
+    if (info.Length() > N){ \
+        if (!info[N].IsString()) \
+            THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be string"); \
+        NAME = *String::Utf8Value(info[N].ToString()); \
+    }
 
 #define DOUBLE_ARG(NAME, N) \
-	if (!info[N].IsNumber()) \
-		THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be number"); \
-	NAME = info[N].ToNumber()->Value();
+    if (!info[N].IsNumber()) \
+        THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be number"); \
+    NAME = info[N].ToNumber()->Value();
 
 #define INT_ARG(NAME, N) \
-	if (!info[N].IsNumber()) \
-		THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be number"); \
-	NAME = info[N].As<Napi::Number>().Int32Value();
+    if (!info[N].IsNumber()) \
+        THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be number"); \
+    NAME = info[N].As<Napi::Number>().Int32Value();
 
 #define BOOL_ARG(NAME, N) \
-	NAME = false;    \
-	if (info.Length() > N){ \
-		if (!info[N].IsBoolean()) \
-			THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be bool"); \
-		NAME = info[N].ToBoolean()->Value(); \
-	}
+    NAME = false;    \
+    if (info.Length() > N){ \
+        if (!info[N].IsBoolean()) \
+            THROW_BAD_ARGS("Parameter " #NAME " (" #N ") should be bool"); \
+        NAME = info[N].ToBoolean()->Value(); \
+    }

package/src/hotplug/hotplug.h

@@ -0,0 +1,22 @@
+#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
+
+class HotPlugManager {
+public:
+    static std::unique_ptr<HotPlugManager> create();
+
+    virtual int supportedHotplugEvents() = 0;
+
+    virtual void enableHotplug(const Napi::Env& env, ModuleData* instanceData) = 0;
+    virtual void disableHotplug(const Napi::Env& env, ModuleData* instanceData) = 0;
+};
+
+void handleHotplug(HotPlug* info);
+
+#endif

package/src/hotplug/libusb.cc

@@ -0,0 +1,90 @@
+#include "hotplug.h"
+
+struct HotPlug {
+    libusb_device* device;
+    libusb_hotplug_event event;
+    Napi::ObjectReference* hotplugThis;
+};
+
+int LIBUSB_CALL hotplug_callback(libusb_context* ctx, libusb_device* device, libusb_hotplug_event event, void* user_data) {
+    libusb_ref_device(device);
+    ModuleData* instanceData = (ModuleData*)user_data;
+    instanceData->hotplugQueue.post(new HotPlug {device, event, &instanceData->hotplugThis});
+    return 0;
+}
+
+class HotPlugManagerLibUsb: public HotPlugManager {
+    int supportedHotplugEvents() {
+        int res = libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG);
+
+        return res > 0 ? HOTPLUG_SUPPORTS_DEVICES : HOTPLUG_SUPPORTS_NONE;
+    }
+
+    void enableHotplug(const Napi::Env& env, ModuleData* instanceData) {
+        libusb_context* usb_context = instanceData->usb_context;
+        CHECK_USB(libusb_hotplug_register_callback(
+            usb_context,
+            (libusb_hotplug_event)(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
+            (libusb_hotplug_flag)0,
+            LIBUSB_HOTPLUG_MATCH_ANY,
+            LIBUSB_HOTPLUG_MATCH_ANY,
+            LIBUSB_HOTPLUG_MATCH_ANY,
+            hotplug_callback,
+            instanceData,
+            &hotplugHandle
+        ));
+    }
+
+    void disableHotplug(const Napi::Env& env, ModuleData* instanceData) {
+        libusb_context* usb_context = instanceData->usb_context;
+        libusb_hotplug_deregister_callback(usb_context, hotplugHandle);
+    }
+    
+    libusb_hotplug_callback_handle hotplugHandle;
+};
+
+std::unique_ptr<HotPlugManager> HotPlugManager::create() {
+    return std::make_unique<HotPlugManagerLibUsb>();
+}
+
+void handleHotplug(HotPlug* info) {
+    Napi::ObjectReference* hotplugThis = info->hotplugThis;
+    Napi::Env env = hotplugThis->Env();
+    Napi::HandleScope scope(env);
+
+    libusb_device* dev = info->device;
+    libusb_hotplug_event event = info->event;
+    delete info;
+
+    DEBUG_LOG("HandleHotplug %p %i", dev, event);
+
+    Napi::Object v8dev = Device::get(env, dev);
+    libusb_unref_device(dev);
+
+    Napi::Object v8VidPid = Napi::Object::New(env);
+    auto deviceDescriptor = v8dev.Get("deviceDescriptor");
+    if (deviceDescriptor.IsObject()) {
+        v8VidPid.Set("idVendor", deviceDescriptor.As<Napi::Object>().Get("idVendor"));
+        v8VidPid.Set("idProduct", deviceDescriptor.As<Napi::Object>().Get("idProduct"));
+    }
+
+    Napi::String eventName;
+    Napi::String changeEventName;
+    if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+        DEBUG_LOG("Device arrived");
+        eventName = Napi::String::New(env, "attach");
+        changeEventName = Napi::String::New(env, "attachIds");
+
+    } else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+        DEBUG_LOG("Device left");
+        eventName = Napi::String::New(env, "detach");
+        changeEventName = 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, v8dev });
+    hotplugThis->Get("emit").As<Napi::Function>().MakeCallback(hotplugThis->Value(), { changeEventName, v8VidPid });
+}

package/src/hotplug/windows.cc

@@ -0,0 +1,161 @@
+#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 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 0;
+}
+
+class HotPlugManagerWindows : public HotPlugManager
+{
+    int supportedHotplugEvents()
+    {
+        return HOTPLUG_SUPPORTS_IDS;
+    }
+
+    void enableHotplug(const Napi::Env &env, ModuleData *instanceData)
+    {
+        if (isRunning)
+        {
+            return;
+        }
+
+        isRunning = true;
+
+        CM_NOTIFY_FILTER cmNotifyFilter = { 0 };
+        cmNotifyFilter.cbSize = sizeof(cmNotifyFilter);
+        cmNotifyFilter.Flags = 0;
+        cmNotifyFilter.FilterType = CM_NOTIFY_FILTER_TYPE_DEVICEINTERFACE;
+        cmNotifyFilter.u.DeviceInterface.ClassGuid = GUID_DEVINTERFACE_USB_DEVICE;
+    
+        auto res = CM_Register_Notification(&cmNotifyFilter, (PVOID)instanceData, (PCM_NOTIFY_CALLBACK)&MyCMInterfaceNotification, &hcm);
+        if (res != CR_SUCCESS)
+        {
+            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;
+};
+
+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 });
+}