usb 1.7.2-prebuild

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "usb",
+  "description": "Library to access USB devices",
+  "version": "1.7.2-prebuild",
+  "engines": {
+    "node": ">=10"
+  },
+  "keywords": [
+    "usb",
+    "hardware"
+  ],
+  "contributors": [
+    {
+      "name": "Kevin Mehall",
+      "email": "km@kevinmehall.net",
+      "url": "http://kevinmehall.net"
+    },
+    {
+      "name": "Tim Ryan",
+      "email": "tim@technical.io",
+      "url": "http://timryan.org"
+    },
+    {
+      "name": "Rob Moran",
+      "email": "github@thegecko.org",
+      "url": "https://github.com/thegecko"
+    },
+    {
+      "name": "Christopher Klein"
+    }
+  ],
+  "main": "./usb",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thegecko/node-usb.git"
+  },
+  "scripts": {
+    "install": "node-gyp-build",
+    "test": "mocha --require coffeescript/register --grep Module test/*",
+    "full-test": "mocha --require coffeescript/register test/*",
+    "valgrind": "coffee -c test/usb.coffee; valgrind --leak-check=full --show-possibly-lost=no node --expose-gc --trace-gc node_modules/mocha/bin/_mocha -R spec",
+    "prebuild": "prebuildify --napi --strip",
+    "prebuild-darwin": "prebuildify --napi --strip --arch x64+arm64",
+    "prebuild-win32-x86": "prebuildify --napi --strip",
+    "prebuild-win32-x64": "prebuildify --napi --strip",
+    "prebuild-linux-x64": "prebuildify-cross -i ghcr.io/node-usb/centos7-devtoolset7 -i ghcr.io/node-usb/alpine --napi --strip --tag-libc",
+    "prebuild-linux-arm": "prebuildify-cross -i ghcr.io/node-usb/linux-arm64 -i ghcr.io/node-usb/linux-armv7 -i ghcr.io/node-usb/linux-armv6 --napi --strip --tag-armv",
+    "prebuild-android-arm": "prebuildify-cross -i ghcr.io/node-usb/android-arm64 -i ghcr.io/node-usb/android-armv7 --napi --strip --tag-armv",
+    "prebuild-download": "prebuildify-ci download"
+  },
+  "dependencies": {
+    "node-addon-api": "^4.2.0",
+    "node-gyp-build": "^4.3.0"
+  },
+  "devDependencies": {
+    "coffeescript": "~2.4.1",
+    "mocha": "^8.3.2",
+    "node-gyp": "^7.1.2",
+    "prebuildify": "^4.2.1",
+    "prebuildify-ci": "^1.0.5",
+    "prebuildify-cross": "^4.0.1"
+  },
+  "license": "MIT",
+  "binary": {
+    "napi_versions": [
+      4
+    ]
+  }
+}

package/src/device.cc

@@ -0,0 +1,412 @@
+#include "node_usb.h"
+#include <string.h>
+
+#define STRUCT_TO_V8(TARGET, STR, NAME) \
+	TARGET.DefineProperty(Napi::PropertyDescriptor::Value(#NAME, Napi::Number::New(env, (uint32_t) (STR).NAME), CONST_PROP));
+
+#define CHECK_OPEN() \
+	if (!self->device_handle){THROW_ERROR("Device is not opened");}
+
+#define MAX_PORTS 7
+
+Napi::FunctionReference Device::constructor;
+
+Device::Device(const Napi::CallbackInfo & info) : Napi::ObjectWrap<Device>(info), device_handle(0), refs_(0)
+#ifndef USE_POLL
+, completionQueue(handleCompletion)
+#endif
+{
+	device = info[0].As<Napi::External<libusb_device>>().Data();
+	libusb_ref_device(device);
+	byPtr.insert(std::make_pair(device, this));
+#ifndef USE_POLL
+	completionQueue.start(info.Env());
+#endif
+	DEBUG_LOG("Created device %p", this);
+	Constructor(info);
+}
+
+Device::~Device(){
+	DEBUG_LOG("Freed device %p", this);
+#ifndef USE_POLL
+	completionQueue.stop();
+#endif
+	byPtr.erase(device);
+	libusb_close(device_handle);
+	libusb_unref_device(device);
+}
+
+// Map pinning each libusb_device to a particular V8 instance
+std::map<libusb_device*, Device*> Device::byPtr;
+
+// Get a V8 instance for a libusb_device: either the existing one from the map,
+// or create a new one and add it to the map.
+Napi::Object Device::get(napi_env env, libusb_device* dev){
+	auto it = byPtr.find(dev);
+	if (it != byPtr.end()){
+		return it->second->Value();
+	} else {
+		Napi::Object obj = Device::constructor.New({ Napi::External<libusb_device>::New(env, dev) });
+		return obj;
+	}
+}
+
+Napi::Value Device::Constructor(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
+	ENTER_CONSTRUCTOR_POINTER(Device, 1);
+	auto obj = info.This().As<Napi::Object>();
+	obj.DefineProperty(Napi::PropertyDescriptor::Value("busNumber", Napi::Number::New(env, libusb_get_bus_number(self->device)), CONST_PROP));
+	obj.DefineProperty(Napi::PropertyDescriptor::Value("deviceAddress", Napi::Number::New(env, libusb_get_device_address(self->device)), CONST_PROP));
+
+	Napi::Object v8dd = Napi::Object::New(env);
+	obj.DefineProperty(Napi::PropertyDescriptor::Value("deviceDescriptor", v8dd, CONST_PROP));
+
+	struct libusb_device_descriptor dd;
+	CHECK_USB(libusb_get_device_descriptor(self->device, &dd));
+
+	STRUCT_TO_V8(v8dd, dd, bLength)
+	STRUCT_TO_V8(v8dd, dd, bDescriptorType)
+	STRUCT_TO_V8(v8dd, dd, bcdUSB)
+	STRUCT_TO_V8(v8dd, dd, bDeviceClass)
+	STRUCT_TO_V8(v8dd, dd, bDeviceSubClass)
+	STRUCT_TO_V8(v8dd, dd, bDeviceProtocol)
+	STRUCT_TO_V8(v8dd, dd, bMaxPacketSize0)
+	STRUCT_TO_V8(v8dd, dd, idVendor)
+	STRUCT_TO_V8(v8dd, dd, idProduct)
+	STRUCT_TO_V8(v8dd, dd, bcdDevice)
+	STRUCT_TO_V8(v8dd, dd, iManufacturer)
+	STRUCT_TO_V8(v8dd, dd, iProduct)
+	STRUCT_TO_V8(v8dd, dd, iSerialNumber)
+	STRUCT_TO_V8(v8dd, dd, bNumConfigurations)
+
+	uint8_t port_numbers[MAX_PORTS];
+	int ret = libusb_get_port_numbers(self->device, &port_numbers[0], MAX_PORTS);
+	if (ret > 0) {
+		Napi::Array array = Napi::Array::New(env, ret);
+		for (int i = 0; i < ret; ++ i) {
+			array.Set(i, Napi::Number::New(env, port_numbers[i]));
+		}
+		obj.DefineProperty(Napi::PropertyDescriptor::Value("portNumbers", array, CONST_PROP));
+	}
+	return info.This();
+}
+
+Napi::Object Device::cdesc2V8(napi_env env, libusb_config_descriptor * cdesc){
+	Napi::Object v8cdesc = Napi::Object::New(env);
+
+	STRUCT_TO_V8(v8cdesc, *cdesc, bLength)
+	STRUCT_TO_V8(v8cdesc, *cdesc, bDescriptorType)
+	STRUCT_TO_V8(v8cdesc, *cdesc, wTotalLength)
+	STRUCT_TO_V8(v8cdesc, *cdesc, bNumInterfaces)
+	STRUCT_TO_V8(v8cdesc, *cdesc, bConfigurationValue)
+	STRUCT_TO_V8(v8cdesc, *cdesc, iConfiguration)
+	STRUCT_TO_V8(v8cdesc, *cdesc, bmAttributes)
+	// Libusb 1.0 typo'd bMaxPower as MaxPower
+	v8cdesc.DefineProperty(Napi::PropertyDescriptor::Value("bMaxPower", Napi::Number::New(env, (uint32_t)cdesc->MaxPower), CONST_PROP));
+
+	v8cdesc.DefineProperty(Napi::PropertyDescriptor::Value("extra", Napi::Buffer<const char>::Copy(env, (const char*)cdesc->extra, cdesc->extra_length), CONST_PROP));
+
+	Napi::Array v8interfaces = Napi::Array::New(env, cdesc->bNumInterfaces);
+	v8cdesc.DefineProperty(Napi::PropertyDescriptor::Value("interfaces", v8interfaces, CONST_PROP));
+
+	for (int idxInterface = 0; idxInterface < cdesc->bNumInterfaces; idxInterface++) {
+		int numAltSettings = cdesc->interface[idxInterface].num_altsetting;
+
+		Napi::Array v8altsettings = Napi::Array::New(env, numAltSettings);
+		v8interfaces.Set(idxInterface, v8altsettings);
+
+		for (int idxAltSetting = 0; idxAltSetting < numAltSettings; idxAltSetting++) {
+			const libusb_interface_descriptor& idesc =
+				cdesc->interface[idxInterface].altsetting[idxAltSetting];
+
+			Napi::Object v8idesc = Napi::Object::New(env);
+			v8altsettings.Set(idxAltSetting, v8idesc);
+
+			STRUCT_TO_V8(v8idesc, idesc, bLength)
+			STRUCT_TO_V8(v8idesc, idesc, bDescriptorType)
+			STRUCT_TO_V8(v8idesc, idesc, bInterfaceNumber)
+			STRUCT_TO_V8(v8idesc, idesc, bAlternateSetting)
+			STRUCT_TO_V8(v8idesc, idesc, bNumEndpoints)
+			STRUCT_TO_V8(v8idesc, idesc, bInterfaceClass)
+			STRUCT_TO_V8(v8idesc, idesc, bInterfaceSubClass)
+			STRUCT_TO_V8(v8idesc, idesc, bInterfaceProtocol)
+			STRUCT_TO_V8(v8idesc, idesc, iInterface)
+
+			v8idesc.DefineProperty(Napi::PropertyDescriptor::Value("extra", Napi::Buffer<const char>::Copy(env, (const char*)idesc.extra, idesc.extra_length), CONST_PROP));
+
+			Napi::Array v8endpoints = Napi::Array::New(env, idesc.bNumEndpoints);
+			v8idesc.DefineProperty(Napi::PropertyDescriptor::Value("endpoints", v8endpoints, CONST_PROP));
+			for (int idxEndpoint = 0; idxEndpoint < idesc.bNumEndpoints; idxEndpoint++){
+				const libusb_endpoint_descriptor& edesc = idesc.endpoint[idxEndpoint];
+
+				Napi::Object v8edesc = Napi::Object::New(env);
+				v8endpoints.Set(idxEndpoint, v8edesc);
+
+				STRUCT_TO_V8(v8edesc, edesc, bLength)
+				STRUCT_TO_V8(v8edesc, edesc, bDescriptorType)
+				STRUCT_TO_V8(v8edesc, edesc, bEndpointAddress)
+				STRUCT_TO_V8(v8edesc, edesc, bmAttributes)
+				STRUCT_TO_V8(v8edesc, edesc, wMaxPacketSize)
+				STRUCT_TO_V8(v8edesc, edesc, bInterval)
+				STRUCT_TO_V8(v8edesc, edesc, bRefresh)
+				STRUCT_TO_V8(v8edesc, edesc, bSynchAddress)
+
+				v8edesc.DefineProperty(Napi::PropertyDescriptor::Value("extra", Napi::Buffer<const char>::Copy(env, (const char*)edesc.extra, edesc.extra_length), CONST_PROP));
+			}
+		}
+	}
+	return v8cdesc;
+}
+
+Napi::Value Device::GetConfigDescriptor(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 0);
+	libusb_config_descriptor* cdesc;
+	CHECK_USB(libusb_get_active_config_descriptor(self->device, &cdesc));
+	Napi::Object v8cdesc = Device::cdesc2V8(env, cdesc);
+	libusb_free_config_descriptor(cdesc);
+	return v8cdesc;
+}
+
+Napi::Value Device::GetAllConfigDescriptors(const Napi::CallbackInfo& info){
+	ENTER_METHOD(Device, 0);
+	libusb_config_descriptor * cdesc;
+	struct libusb_device_descriptor dd;
+	libusb_get_device_descriptor(self->device, &dd);
+	Napi::Array v8cdescriptors = Napi::Array::New(env, dd.bNumConfigurations);
+	for(uint8_t i = 0; i < dd.bNumConfigurations; i++){
+		libusb_get_config_descriptor(device, i, &cdesc);
+		v8cdescriptors.Set(i, Device::cdesc2V8(env, cdesc));
+		libusb_free_config_descriptor(cdesc);
+	}
+	return v8cdescriptors;
+}
+
+Napi::Value Device::GetParent(const Napi::CallbackInfo& info){
+	ENTER_METHOD(Device, 0);
+	libusb_device* dev = libusb_get_parent(self->device);
+	if(dev)
+		return Device::get(env, dev);
+	else
+		return env.Null();
+}
+
+Napi::Value Device::Open(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 0);
+	if (!self->device_handle){
+		CHECK_USB(libusb_open(self->device, &self->device_handle));
+	}
+	return env.Undefined();
+}
+
+Napi::Value Device::Close(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 0);
+	if (self->canClose()){
+		libusb_close(self->device_handle);
+		self->device_handle = NULL;
+	}else{
+		THROW_ERROR("Can't close device with a pending request");
+	}
+	return env.Undefined();
+}
+
+struct Req: Napi::AsyncWorker {
+	Device* device;
+	int errcode;
+
+	Req(Device* d, Napi::Function& callback)
+		: Napi::AsyncWorker(callback), device(d) {
+		device->ref();
+	}
+
+    void OnOK() override {
+		auto env = Env();
+        Napi::HandleScope scope(env);
+		device->unref();
+
+		Napi::Value error = env.Undefined();
+		if (errcode < 0){
+			error = libusbException(env, errcode).Value();
+		}
+		try {
+			Callback().Call(device->Value(), { error });
+		}
+		catch (const Napi::Error& e) {
+			Napi::Error::Fatal("", e.what());
+		}
+    }
+};
+
+struct Device_Reset: Req {
+	Device_Reset(Device* d, Napi::Function& callback): Req(d, callback) {}
+
+	virtual void Execute() {
+		errcode = libusb_reset_device(device->device_handle);
+	}
+};
+
+Napi::Value Device::Reset(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 1);
+	CHECK_OPEN();
+	CALLBACK_ARG(0);
+	auto baton = new Device_Reset(self, callback);
+	baton->Queue();
+	return env.Undefined();
+}
+
+struct Device_Clear_Halt: Req {
+	Device_Clear_Halt(Device* d, Napi::Function& callback): Req(d, callback) {}
+
+	int endpoint;
+
+	virtual void Execute() {
+		errcode = libusb_clear_halt(device->device_handle, endpoint);
+	}
+};
+
+Napi::Value Device::ClearHalt(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 2);
+	int endpoint;
+	CHECK_OPEN();
+	INT_ARG(endpoint, 0);
+	CALLBACK_ARG(1);
+	auto baton = new Device_Clear_Halt(self, callback);
+	baton->endpoint = endpoint;
+	baton->Queue();
+	return env.Undefined();
+}
+
+Napi::Value Device::IsKernelDriverActive(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 1);
+	CHECK_OPEN();
+	int interface;
+	INT_ARG(interface, 0);
+	int r = libusb_kernel_driver_active(self->device_handle, interface);
+	CHECK_USB(r);
+	return Napi::Boolean::New(env, r);
+}
+
+Napi::Value Device::DetachKernelDriver(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 1);
+	CHECK_OPEN();
+	int interface;
+	INT_ARG(interface, 0);
+	CHECK_USB(libusb_detach_kernel_driver(self->device_handle, interface));
+	return env.Undefined();
+}
+
+Napi::Value Device::AttachKernelDriver(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 1);
+	CHECK_OPEN();
+	int interface;
+	INT_ARG(interface, 0);
+	CHECK_USB(libusb_attach_kernel_driver(self->device_handle, interface));
+	return env.Undefined();
+}
+
+Napi::Value Device::ClaimInterface(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 1);
+	CHECK_OPEN();
+	int interface;
+	INT_ARG(interface, 0);
+	CHECK_USB(libusb_claim_interface(self->device_handle, interface));
+	return env.Undefined();
+}
+
+struct Device_ReleaseInterface: Req {
+	Device_ReleaseInterface(Device* d, Napi::Function& callback): Req(d, callback) {}
+
+	int interface;
+
+	virtual void Execute() {
+		errcode = libusb_release_interface(device->device_handle, interface);
+	}
+};
+
+Napi::Value Device::ReleaseInterface(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 2);
+	CHECK_OPEN();
+	int interface;
+	INT_ARG(interface, 0);
+	CALLBACK_ARG(1);
+	auto baton = new Device_ReleaseInterface(self, callback);
+	baton->interface = interface;
+	baton->Queue();
+	return env.Undefined();
+}
+
+struct Device_SetInterface: Req {
+	Device_SetInterface(Device* d, Napi::Function& callback): Req(d, callback) {}
+
+	int interface;
+	int altsetting;
+
+	virtual void Execute() {
+		errcode = libusb_set_interface_alt_setting(
+			device->device_handle, interface, altsetting);
+	}
+};
+
+Napi::Value Device::SetInterface(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 3);
+	CHECK_OPEN();
+	int interface, altsetting;
+	INT_ARG(interface, 0);
+	INT_ARG(altsetting, 1);
+	CALLBACK_ARG(2);
+	auto baton = new Device_SetInterface(self, callback);
+	baton->interface = interface;
+	baton->altsetting = altsetting;
+	baton->Queue();
+	return env.Undefined();
+}
+
+struct Device_SetConfiguration: Req {
+	Device_SetConfiguration(Device* d, Napi::Function& callback): Req(d, callback) {}
+
+	int desired;
+
+	virtual void Execute() {
+		errcode = libusb_set_configuration(
+			device->device_handle, desired);
+	}
+};
+
+Napi::Value Device::SetConfiguration(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Device, 2);
+	CHECK_OPEN();
+	int desired;
+	INT_ARG(desired, 0);
+	CALLBACK_ARG(1);
+	auto baton = new Device_SetConfiguration(self, callback);
+	baton->desired = desired;
+	baton->Queue();
+	return env.Undefined();
+}
+
+Napi::Object Device::Init(Napi::Env env, Napi::Object exports) {
+	auto func = Device::DefineClass(
+		env,
+		"Device",
+		{
+			Device::InstanceMethod("__getParent", &Device::GetParent),
+			Device::InstanceMethod("__getConfigDescriptor", &Device::GetConfigDescriptor),
+			Device::InstanceMethod("__getAllConfigDescriptors", &Device::GetAllConfigDescriptors),
+			Device::InstanceMethod("__open", &Device::Open),
+			Device::InstanceMethod("__close", &Device::Close),
+			Device::InstanceMethod("__clearHalt", &Device::ClearHalt),
+			Device::InstanceMethod("reset", &Device::Reset),
+			Device::InstanceMethod("__claimInterface", &Device::ClaimInterface),
+			Device::InstanceMethod("__releaseInterface", &Device::ReleaseInterface),
+			Device::InstanceMethod("__setInterface", &Device::SetInterface),
+			Device::InstanceMethod("__setConfiguration", &Device::SetConfiguration),
+			Device::InstanceMethod("__isKernelDriverActive", &Device::IsKernelDriverActive),
+			Device::InstanceMethod("__detachKernelDriver", &Device::DetachKernelDriver),
+			Device::InstanceMethod("__attachKernelDriver", &Device::AttachKernelDriver),
+		});
+	exports.Set("Device", func);
+
+	Device::constructor = Napi::Persistent(func);
+	Device::constructor.SuppressDestruct();
+
+	return exports;
+}

package/src/helpers.h

@@ -0,0 +1,64 @@
+#include <vector>
+#include <napi.h>
+
+#define THROW_BAD_ARGS(FAIL_MSG) throw Napi::TypeError::New(env, FAIL_MSG);
+#define THROW_ERROR(FAIL_MSG) throw Napi::Error::New(env, FAIL_MSG);
+
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#define CHECK_N_ARGS(MIN_ARGS) if ((MIN_ARGS) > 0 && info.Length() < (MIN_ARGS)) { THROW_BAD_ARGS("Expected " #MIN_ARGS " arguments") }
+
+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);
+
+#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;
+
+#define ENTER_METHOD(CLASS, MIN_ARGS) \
+	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>();
+
+#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");
+
+#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()); \
+	}
+
+#define DOUBLE_ARG(NAME, N) \
+	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();
+
+#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(); \
+	}