usb 2.17.0 → 3.0.0-alpha.2

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 });
-}

package/src/node_usb.cc

@@ -1,314 +0,0 @@
-#include "node_usb.h"
-#include "thread_name.h"
-#include "hotplug/hotplug.h"
-
-Napi::Value SetDebugLevel(const Napi::CallbackInfo& info);
-Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info);
-Napi::Value GetDeviceList(const Napi::CallbackInfo& info);
-Napi::Value GetLibusbCapability(const Napi::CallbackInfo& info);
-Napi::Value SupportedHotplugEvents(const Napi::CallbackInfo& info);
-Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info);
-Napi::Value DisableHotplugEvents(const Napi::CallbackInfo& info);
-Napi::Value RefHotplugEvents(const Napi::CallbackInfo& info);
-Napi::Value UnrefHotplugEvents(const Napi::CallbackInfo& info);
-void initConstants(Napi::Object target);
-
-void USBThreadFn(ModuleData* instanceData) {
-    SetThreadName("node-usb events");
-    libusb_context* usb_context = instanceData->usb_context;
-
-    while(true) {
-        if (instanceData->handlingEvents == false) {
-            break;
-        }
-        libusb_handle_events(usb_context);
-    }
-}
-
-ModuleData::ModuleData(libusb_context* usb_context) : usb_context(usb_context), hotplugQueue(handleHotplug) {
-    handlingEvents = true;
-    usb_thread = std::thread(USBThreadFn, this);
-    hotplugManager = HotPlugManager::create();
-}
-
-ModuleData::~ModuleData() {
-    handlingEvents = false;
-    libusb_interrupt_event_handler(usb_context);
-    usb_thread.join();
-
-    if (usb_context != nullptr) {
-        libusb_exit(usb_context);
-        usb_context = nullptr;
-    }
-}
-
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-    Napi::HandleScope scope(env);
-    initConstants(exports);
-
-    // Initialize libusb. On error, halt initialization.
-    libusb_context* usb_context = nullptr;
-    int res = libusb_init(&usb_context);
-
-    exports.Set("INIT_ERROR", Napi::Number::New(env, res));
-    if (res != 0) {
-        return exports;
-    }
-
-    env.SetInstanceData(new ModuleData(usb_context));
-
-    Device::Init(env, exports);
-    Transfer::Init(env, exports);
-
-    exports.Set("setDebugLevel", Napi::Function::New(env, SetDebugLevel));
-    exports.Set("useUsbDkBackend", Napi::Function::New(env, UseUsbDkBackend));
-    exports.Set("getDeviceList", Napi::Function::New(env, GetDeviceList));
-    exports.Set("_getLibusbCapability", Napi::Function::New(env, GetLibusbCapability));
-    exports.Set("_supportedHotplugEvents", Napi::Function::New(env, SupportedHotplugEvents));
-    exports.Set("_enableHotplugEvents", Napi::Function::New(env, EnableHotplugEvents));
-    exports.Set("_disableHotplugEvents", Napi::Function::New(env, DisableHotplugEvents));
-    exports.Set("refHotplugEvents", Napi::Function::New(env, RefHotplugEvents));
-    exports.Set("unrefHotplugEvents", Napi::Function::New(env, UnrefHotplugEvents));
-    return exports;
-}
-
-NODE_API_MODULE(usb_bindings, Init)
-
-Napi::Value SetDebugLevel(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    if (info.Length() != 1 || !info[0].IsNumber() || info[0].As<Napi::Number>().Uint32Value() > 4) {
-        THROW_BAD_ARGS("Usb::SetDebugLevel argument is invalid. [uint:[0-4]]!")
-    }
-
-    libusb_context* usb_context = env.GetInstanceData<ModuleData>()->usb_context;
-    libusb_set_option(usb_context, LIBUSB_OPTION_LOG_LEVEL, info[0].As<Napi::Number>().Int32Value());
-    return env.Undefined();
-}
-
-Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-
-    libusb_context* usb_context = env.GetInstanceData<ModuleData>()->usb_context;
-    libusb_set_option(usb_context, LIBUSB_OPTION_USE_USBDK);
-    return env.Undefined();
-}
-
-Napi::Value GetDeviceList(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    libusb_device** devs;
-
-    libusb_context* usb_context = env.GetInstanceData<ModuleData>()->usb_context;
-    int cnt = libusb_get_device_list(usb_context, &devs);
-    CHECK_USB(cnt);
-
-    Napi::Array arr = Napi::Array::New(env, cnt);
-
-    for(int i = 0; i < cnt; i++) {
-        // DEBUG_LOG("Address %u", libusb_get_device_address(devs[i]));
-        arr.Set(i, Device::get(env, devs[i]));
-    }
-    libusb_free_device_list(devs, true);
-    return arr;
-}
-
-Napi::Value GetLibusbCapability(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-
-    if (info.Length() != 1 || !info[0].IsNumber()) {
-        THROW_BAD_ARGS("Usb::GetLibusbCapability argument is invalid!")
-    }
-
-    int res = libusb_has_capability(info[0].As<Napi::Number>().Int32Value());
-    return Napi::Number::New(env, res);
-}
-
-Napi::Value SupportedHotplugEvents(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-
-    int res = instanceData->hotplugManager->supportedHotplugEvents();
-    return Napi::Number::New(env, res);
-}
-
-Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-
-    if (!instanceData->hotplugEnabled) {
-        instanceData->hotplugThis.Reset(info.This().As<Napi::Object>(), 1);
-
-        // Start queue, then enable hotplug events
-        instanceData->hotplugQueue.start(env);
-        instanceData->hotplugManager->enableHotplug(env, instanceData);
-        
-        instanceData->hotplugEnabled = true;
-    }
-    return env.Undefined();
-}
-
-Napi::Value DisableHotplugEvents(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-
-    if (instanceData->hotplugEnabled) {
-
-        // Disable events, then stop queue
-        instanceData->hotplugManager->disableHotplug(env, instanceData);
-        instanceData->hotplugQueue.stop();
-
-        instanceData->hotplugEnabled = false;
-    }
-    return env.Undefined();
-}
-
-Napi::Value RefHotplugEvents(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-
-    if (instanceData->hotplugEnabled) {
-        instanceData->hotplugQueue.ref(env);
-    }
-    return env.Undefined();
-}
-
-Napi::Value UnrefHotplugEvents(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    ModuleData* instanceData = env.GetInstanceData<ModuleData>();
-
-    if (instanceData->hotplugEnabled) {
-        instanceData->hotplugQueue.unref(env);
-    }
-    return env.Undefined();
-}
-
-#define DEFINE_CONSTANT(OBJ, VALUE) \
-    OBJ.DefineProperty(Napi::PropertyDescriptor::Value(#VALUE, Napi::Number::New(OBJ.Env(), VALUE), static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)));
-
-void initConstants(Napi::Object target){
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_PER_INTERFACE);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_AUDIO);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_COMM);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_HID);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_PRINTER);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_PTP);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_MASS_STORAGE);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_HUB);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_DATA);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_WIRELESS);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_APPLICATION);
-    DEFINE_CONSTANT(target, LIBUSB_CLASS_VENDOR_SPEC);
-    // libusb_standard_request
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_GET_STATUS);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_CLEAR_FEATURE);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_SET_FEATURE);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_SET_ADDRESS );
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_GET_DESCRIPTOR);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_SET_DESCRIPTOR);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_GET_CONFIGURATION);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_SET_CONFIGURATION );
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_GET_INTERFACE);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_SET_INTERFACE);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_SYNCH_FRAME);
-    // libusb_descriptor_type
-    DEFINE_CONSTANT(target, LIBUSB_DT_DEVICE);
-    DEFINE_CONSTANT(target, LIBUSB_DT_CONFIG);
-    DEFINE_CONSTANT(target, LIBUSB_DT_STRING);
-    DEFINE_CONSTANT(target, LIBUSB_DT_BOS);
-    DEFINE_CONSTANT(target, LIBUSB_DT_INTERFACE);
-    DEFINE_CONSTANT(target, LIBUSB_DT_ENDPOINT);
-    DEFINE_CONSTANT(target, LIBUSB_DT_HID);
-    DEFINE_CONSTANT(target, LIBUSB_DT_REPORT);
-    DEFINE_CONSTANT(target, LIBUSB_DT_PHYSICAL);
-    DEFINE_CONSTANT(target, LIBUSB_DT_HUB);
-    // libusb_endpoint_direction
-    DEFINE_CONSTANT(target, LIBUSB_ENDPOINT_IN);
-    DEFINE_CONSTANT(target, LIBUSB_ENDPOINT_OUT);
-    // libusb_transfer_type
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_TYPE_CONTROL);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_TYPE_ISOCHRONOUS);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_TYPE_BULK);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_TYPE_INTERRUPT);
-    // libusb_iso_sync_type
-    DEFINE_CONSTANT(target, LIBUSB_ISO_SYNC_TYPE_NONE);
-    DEFINE_CONSTANT(target, LIBUSB_ISO_SYNC_TYPE_ASYNC);
-    DEFINE_CONSTANT(target, LIBUSB_ISO_SYNC_TYPE_ADAPTIVE);
-    DEFINE_CONSTANT(target, LIBUSB_ISO_SYNC_TYPE_SYNC);
-    // libusb_iso_usage_type
-    DEFINE_CONSTANT(target, LIBUSB_ISO_USAGE_TYPE_DATA);
-    DEFINE_CONSTANT(target, LIBUSB_ISO_USAGE_TYPE_FEEDBACK);
-    DEFINE_CONSTANT(target, LIBUSB_ISO_USAGE_TYPE_IMPLICIT);
-    // libusb_transfer_status
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_COMPLETED);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_ERROR);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_TIMED_OUT);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_CANCELLED);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_STALL);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_NO_DEVICE);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_OVERFLOW);
-    // libusb_transfer_flags
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_SHORT_NOT_OK);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_FREE_BUFFER);
-    DEFINE_CONSTANT(target, LIBUSB_TRANSFER_FREE_TRANSFER);
-    // libusb_request_type
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_TYPE_STANDARD);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_TYPE_CLASS);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_TYPE_VENDOR);
-    DEFINE_CONSTANT(target, LIBUSB_REQUEST_TYPE_RESERVED);
-    // libusb_request_recipient
-    DEFINE_CONSTANT(target, LIBUSB_RECIPIENT_DEVICE);
-    DEFINE_CONSTANT(target, LIBUSB_RECIPIENT_INTERFACE);
-    DEFINE_CONSTANT(target, LIBUSB_RECIPIENT_ENDPOINT);
-    DEFINE_CONSTANT(target, LIBUSB_RECIPIENT_OTHER);
-
-    DEFINE_CONSTANT(target, LIBUSB_CONTROL_SETUP_SIZE);
-    DEFINE_CONSTANT(target, LIBUSB_DT_BOS_SIZE);
-
-    // libusb_capability
-    DEFINE_CONSTANT(target, LIBUSB_CAP_HAS_CAPABILITY);
-    DEFINE_CONSTANT(target, LIBUSB_CAP_HAS_HOTPLUG);
-    DEFINE_CONSTANT(target, LIBUSB_CAP_HAS_HID_ACCESS);
-    DEFINE_CONSTANT(target, LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER);
-
-    // libusb_error
-    // Input/output error
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_IO);
-    // Invalid parameter
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_INVALID_PARAM);
-    // Access denied (insufficient permissions)
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_ACCESS);
-    // No such device (it may have been disconnected)
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_NO_DEVICE);
-    // Entity not found
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_NOT_FOUND);
-    // Resource busy
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_BUSY);
-    // Operation timed out
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_TIMEOUT);
-    // Overflow
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_OVERFLOW);
-    // Pipe error
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_PIPE);
-    // System call interrupted (perhaps due to signal)
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_INTERRUPTED);
-    // Insufficient memory
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_NO_MEM);
-    // Operation not supported or unimplemented on this platform
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_NOT_SUPPORTED);
-    // Other error
-    DEFINE_CONSTANT(target, LIBUSB_ERROR_OTHER);
-}
-
-Napi::Error libusbException(Napi::Env env, int errorno) {
-    const char* err = libusb_error_name(errorno);
-    Napi::Error e  = Napi::Error::New(env, err);
-    e.Set("errno", (double)errorno);
-    return e;
-}

package/src/node_usb.h

@@ -1,131 +0,0 @@
-#ifndef SRC_NODE_USB_H
-#define SRC_NODE_USB_H
-
-#include <assert.h>
-#include <string>
-#include <map>
-
-#ifdef _WIN32
-#include <WinSock2.h>
-#endif
-
-#include <thread>
-#include <atomic>
-#include <libusb.h>
-#include <napi.h>
-
-#include "helpers.h"
-#include "uv_async_queue.h"
-
-struct Transfer;
-
-struct HotPlug;
-class HotPlugManager;
-
-Napi::Error libusbException(Napi::Env env, int errorno);
-void handleCompletion(Transfer* self);
-
-struct Device: public Napi::ObjectWrap<Device> {
-    Napi::Env env;
-    libusb_device* device;
-    libusb_device_handle* device_handle;
-
-    int refs_;
-    UVQueue<Transfer*> completionQueue;
-
-    static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    static Napi::Object get(Napi::Env env, libusb_device* handle);
-
-    inline void ref(){ refs_ = Ref();}
-    inline void unref(){ refs_ = Unref();}
-    inline bool canClose(){return refs_ == 0;}
-
-    Device(const Napi::CallbackInfo& info);
-    ~Device();
-
-    static Napi::Object cdesc2V8(Napi::Env env, libusb_config_descriptor * cdesc);
-
-    Napi::Value GetConfigDescriptor(const Napi::CallbackInfo& info);
-    Napi::Value GetAllConfigDescriptors(const Napi::CallbackInfo& info);
-    Napi::Value SetConfiguration(const Napi::CallbackInfo& info);
-
-    Napi::Value GetParent(const Napi::CallbackInfo& info);
-    Napi::Value Open(const Napi::CallbackInfo& info);
-    Napi::Value Reset(const Napi::CallbackInfo& info);
-    Napi::Value Close(const Napi::CallbackInfo& info);
-
-    Napi::Value IsKernelDriverActive(const Napi::CallbackInfo& info);
-    Napi::Value DetachKernelDriver(const Napi::CallbackInfo& info);
-    Napi::Value AttachKernelDriver(const Napi::CallbackInfo& info);
-    Napi::Value SetAutoDetachKernelDriver(const Napi::CallbackInfo& info);
-
-    Napi::Value ClaimInterface(const Napi::CallbackInfo& info);
-    Napi::Value SetInterface(const Napi::CallbackInfo& info);
-    Napi::Value ReleaseInterface(const Napi::CallbackInfo& info);
-
-    Napi::Value ClearHalt(const Napi::CallbackInfo& info);
-protected:
-    Napi::Value Constructor(const Napi::CallbackInfo& info);
-};
-
-struct ModuleData {
-    libusb_context* usb_context;
-    std::thread usb_thread;
-    std::atomic<bool> handlingEvents;
-
-    bool hotplugEnabled = 0;
-    std::unique_ptr<HotPlugManager> hotplugManager;
-    UVQueue<HotPlug*> hotplugQueue;
-    Napi::ObjectReference hotplugThis;
-    std::map<libusb_device*, Device*> byPtr;
-    Napi::FunctionReference deviceConstructor;
-
-    ModuleData(libusb_context* usb_context);
-    ~ModuleData();
-};
-
-struct Transfer: public Napi::ObjectWrap<Transfer> {
-    libusb_transfer* transfer;
-    Device* device;
-    Napi::ObjectReference v8buffer;
-    Napi::FunctionReference v8callback;
-
-    static Napi::Object Init(Napi::Env env, Napi::Object exports);
-
-    inline void ref(){Ref();}
-    inline void unref(){Unref();}
-
-    Transfer(const Napi::CallbackInfo& info);
-    ~Transfer();
-
-    Napi::Value Submit(const Napi::CallbackInfo& info);
-    Napi::Value Cancel(const Napi::CallbackInfo& info);
-private:
-    Napi::Value Constructor(const Napi::CallbackInfo& info);
-};
-
-
-
-#define CHECK_USB(r) \
-    if (r < LIBUSB_SUCCESS) { \
-        throw libusbException(env, r); \
-    }
-
-#define CALLBACK_ARG(CALLBACK_ARG_IDX) \
-    Napi::Function callback; \
-    if (info.Length() > (CALLBACK_ARG_IDX)) { \
-        if (!info[CALLBACK_ARG_IDX].IsFunction()) { \
-            throw Napi::TypeError::New(env, "Argument " #CALLBACK_ARG_IDX " must be a function"); \
-        } \
-        callback = info[CALLBACK_ARG_IDX].As<Napi::Function>(); \
-    } \
-
-#ifdef DEBUG
-  #define DEBUG_HEADER fprintf(stderr, "node-usb [%s:%s() %d]: ", __FILE__, __FUNCTION__, __LINE__);
-  #define DEBUG_FOOTER fprintf(stderr, "\n");
-  #define DEBUG_LOG(...) DEBUG_HEADER fprintf(stderr, __VA_ARGS__); DEBUG_FOOTER
-#else
-  #define DEBUG_LOG(...)
-#endif
-
-#endif

package/src/thread_name.cc

@@ -1,79 +0,0 @@
-// 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

@@ -1,11 +0,0 @@
-/**
- * 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);