usb 1.7.2-prebuild

package/src/node_usb.cc

@@ -0,0 +1,319 @@
+#include "node_usb.h"
+#include "uv_async_queue.h"
+#include <thread>
+
+Napi::Value SetDebugLevel(const Napi::CallbackInfo& info);
+Napi::Value GetDeviceList(const Napi::CallbackInfo& info);
+Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info);
+Napi::Value DisableHotplugEvents(const Napi::CallbackInfo& info);
+void initConstants(Napi::Object target);
+
+libusb_context* usb_context;
+struct HotPlug {
+	libusb_device* device;
+	libusb_hotplug_event event;
+};
+
+#ifdef USE_POLL
+#include <poll.h>
+#include <sys/time.h>
+
+std::map<int, uv_poll_t*> pollByFD;
+
+struct timeval zero_tv = {0, 0};
+
+void onPollSuccess(uv_poll_t* handle, int status, int events){
+	libusb_handle_events_timeout(usb_context, &zero_tv);
+}
+
+void LIBUSB_CALL onPollFDAdded(int fd, short events, void *user_data){
+	uv_poll_t *poll_fd;
+	auto it = pollByFD.find(fd);
+	if (it != pollByFD.end()){
+		poll_fd = it->second;
+	}else{
+		poll_fd = (uv_poll_t*) malloc(sizeof(uv_poll_t));
+		uv_poll_init(uv_default_loop(), poll_fd, fd);
+		pollByFD.insert(std::make_pair(fd, poll_fd));
+	}
+
+	DEBUG_LOG("Added pollfd %i, %p", fd, poll_fd);
+	unsigned flags = ((events&POLLIN) ? UV_READABLE:0)
+	               | ((events&POLLOUT)? UV_WRITABLE:0);
+	uv_poll_start(poll_fd, flags, onPollSuccess);
+}
+
+void LIBUSB_CALL onPollFDRemoved(int fd, void *user_data){
+	auto it = pollByFD.find(fd);
+	if (it != pollByFD.end()){
+		DEBUG_LOG("Removed pollfd %i, %p", fd, it->second);
+		uv_poll_stop(it->second);
+		uv_close((uv_handle_t*) it->second, (uv_close_cb) free);
+		pollByFD.erase(it);
+	}
+}
+
+#else
+std::thread usb_thread;
+
+void USBThreadFn(){
+	while(1) libusb_handle_events(usb_context);
+}
+#endif
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+	Napi::HandleScope scope(env);
+
+	initConstants(exports);
+
+	// Initialize libusb. On error, halt initialization.
+	int res = libusb_init(&usb_context);
+	exports.Set("INIT_ERROR", Napi::Number::New(env, res));
+	if (res != 0) {
+		return exports;
+	}
+
+	#ifdef USE_POLL
+	assert(libusb_pollfds_handle_timeouts(usb_context));
+	libusb_set_pollfd_notifiers(usb_context, onPollFDAdded, onPollFDRemoved, NULL);
+
+	const struct libusb_pollfd** pollfds = libusb_get_pollfds(usb_context);
+	assert(pollfds);
+	for(const struct libusb_pollfd** i=pollfds; *i; i++){
+		onPollFDAdded((*i)->fd, (*i)->events, NULL);
+	}
+	free(pollfds);
+
+	#else
+	usb_thread = std::thread(USBThreadFn);
+	usb_thread.detach();
+	#endif
+
+	Device::Init(env, exports);
+	Transfer::Init(env, exports);
+
+	exports.Set("setDebugLevel", Napi::Function::New(env, SetDebugLevel));
+	exports.Set("getDeviceList", Napi::Function::New(env, GetDeviceList));
+	exports.Set("_enableHotplugEvents", Napi::Function::New(env, EnableHotplugEvents));
+	exports.Set("_disableHotplugEvents", Napi::Function::New(env, DisableHotplugEvents));
+	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_set_debug(usb_context, info[0].As<Napi::Number>().Int32Value());
+	return env.Undefined();
+}
+
+Napi::Value GetDeviceList(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
+	Napi::HandleScope scope(env);
+	libusb_device **devs;
+	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++) {
+		arr.Set(i, Device::get(env, devs[i]));
+	}
+	libusb_free_device_list(devs, true);
+	return arr;
+}
+
+Napi::ObjectReference hotplugThis;
+
+void handleHotplug(HotPlug* info){
+	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::Value v8dev = Device::get(env, dev);
+	libusb_unref_device(dev);
+
+	Napi::String eventName;
+	if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+		DEBUG_LOG("Device arrived");
+		eventName = Napi::String::New(env, "attach");
+
+	} else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+		DEBUG_LOG("Device left");
+		eventName = Napi::String::New(env, "detach");
+
+	} else {
+		DEBUG_LOG("Unhandled hotplug event %d\n", event);
+		return;
+	}
+
+	hotplugThis.Get("emit").As<Napi::Function>().MakeCallback(hotplugThis.Value(), { eventName, v8dev });
+}
+
+bool hotplugEnabled = 0;
+libusb_hotplug_callback_handle hotplugHandle;
+UVQueue<HotPlug*> hotplugQueue(handleHotplug);
+
+int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *device,
+                     libusb_hotplug_event event, void *user_data) {
+	libusb_ref_device(device);
+	hotplugQueue.post(new HotPlug {device, event});
+	return 0;
+}
+
+Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
+	Napi::HandleScope scope(env);
+
+	if (!hotplugEnabled) {
+		hotplugThis.Reset(info.This().As<Napi::Object>(), 1);
+		hotplugThis.SuppressDestruct();
+		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, NULL, &hotplugHandle));
+		hotplugQueue.start(env);
+		hotplugEnabled = true;
+	}
+	return env.Undefined();
+}
+
+Napi::Value DisableHotplugEvents(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
+	Napi::HandleScope scope(env);
+	if (hotplugEnabled) {
+		libusb_hotplug_deregister_callback(usb_context, hotplugHandle);
+		hotplugQueue.stop();
+		hotplugEnabled = false;
+	}
+	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_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

@@ -0,0 +1,120 @@
+#ifndef SRC_NODE_USB_H
+#define SRC_NODE_USB_H
+
+#include <assert.h>
+#include <string>
+#include <map>
+
+#ifdef _WIN32
+#include <WinSock2.h>
+#endif
+#include <libusb.h>
+
+#include <napi.h>
+#include <node_buffer.h>
+
+#include "helpers.h"
+
+#ifndef USE_POLL
+#include "uv_async_queue.h"
+#endif
+
+struct Transfer;
+
+Napi::Error libusbException(napi_env env, int errorno);
+void handleCompletion(Transfer* self);
+
+struct Device: public Napi::ObjectWrap<Device> {
+	libusb_device* device;
+	libusb_device_handle* device_handle;
+
+	int refs_;
+
+#ifndef USE_POLL
+	UVQueue<Transfer*> completionQueue;
+#endif
+
+	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 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:
+	static std::map<libusb_device*, Device*> byPtr;
+	static Napi::FunctionReference constructor;
+	
+	Napi::Value Constructor(const Napi::CallbackInfo& info);
+};
+
+
+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/transfer.cc

@@ -0,0 +1,148 @@
+#include "node_usb.h"
+
+extern "C" void LIBUSB_CALL usbCompletionCb(libusb_transfer *transfer);
+
+Transfer::Transfer(const Napi::CallbackInfo& info)
+	: Napi::ObjectWrap<Transfer>(info) {
+	transfer = libusb_alloc_transfer(0);
+	transfer->callback = usbCompletionCb;
+	transfer->user_data = this;
+	DEBUG_LOG("Created Transfer %p", this);
+	Constructor(info);
+}
+
+Transfer::~Transfer(){
+	DEBUG_LOG("Freed Transfer %p", this);
+	v8callback.Reset();
+	libusb_free_transfer(transfer);
+}
+
+// new Transfer(device, endpointAddr, type, timeout)
+Napi::Value Transfer::Constructor(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
+	ENTER_CONSTRUCTOR(5);
+	UNWRAP_ARG(Device, device, 0);
+	int endpoint, type, timeout;
+	INT_ARG(endpoint, 1);
+	INT_ARG(type, 2);
+	INT_ARG(timeout, 3);
+	CALLBACK_ARG(4);
+
+	info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value(std::string("device"), info[0], CONST_PROP));
+	auto self = this;
+	self->device = device;
+	self->transfer->endpoint = endpoint;
+	self->transfer->type = type;
+	self->transfer->timeout = timeout;
+
+	self->v8callback.Reset(callback, 1);
+
+	return info.This();
+}
+
+// Transfer.submit(buffer, callback)
+Napi::Value Transfer::Submit(const Napi::CallbackInfo& info) {
+	ENTER_METHOD(Transfer, 1);
+
+	if (self->transfer->buffer){
+		THROW_ERROR("Transfer is already active")
+	}
+
+	if (!info[0].IsBuffer()){
+		THROW_BAD_ARGS("Buffer arg [0] must be Buffer");
+	}
+	Napi::Buffer<unsigned char> buffer_obj = info[0].As<Napi::Buffer<unsigned char>>();
+	if (!self->device->device_handle){
+		THROW_ERROR("Device is not open");
+	}
+
+	// Can't be cached in constructor as device could be closed and re-opened
+	self->transfer->dev_handle = self->device->device_handle;
+
+	self->v8buffer.Reset(buffer_obj, 1);
+	self->transfer->buffer = (unsigned char*) buffer_obj.Data();
+	self->transfer->length = buffer_obj.ByteLength();
+
+	DEBUG_LOG("Submitting, %p %p %x %i %i %i %p",
+		self,
+		self->transfer->dev_handle,
+		self->transfer->endpoint,
+		self->transfer->type,
+		self->transfer->timeout,
+		self->transfer->length,
+		self->transfer->buffer
+	);
+
+	CHECK_USB(libusb_submit_transfer(self->transfer));
+	self->ref();
+	self->device->ref();
+
+	return info.This();
+}
+
+extern "C" void LIBUSB_CALL usbCompletionCb(libusb_transfer *transfer){
+	Transfer* t = static_cast<Transfer*>(transfer->user_data);
+	DEBUG_LOG("Completion callback %p", t);
+	assert(t != NULL);
+
+	#ifdef USE_POLL
+	handleCompletion(t);
+	#else
+	t->device->completionQueue.post(t);
+	#endif
+}
+
+void handleCompletion(Transfer* self){
+	Napi::Env env = self->Env();
+	Napi::HandleScope scope(env);
+	DEBUG_LOG("HandleCompletion %p", self);
+
+	self->device->unref();
+
+	// The callback may resubmit and overwrite these, so need to clear the
+	// persistent first.
+	Napi::Object buffer = self->v8buffer.Value();
+	self->v8buffer.Reset();
+	self->transfer->buffer = NULL;
+
+	if (!self->v8callback.IsEmpty()) {
+		Napi::Value error = env.Undefined();
+		if (self->transfer->status != 0){
+			error = libusbException(env, self->transfer->status).Value();
+		}
+		try {
+			self->v8callback.MakeCallback(self->Value(), { error, buffer,
+				Napi::Number::New(env, (uint32_t)self->transfer->actual_length) });
+		}
+		catch (const Napi::Error& e) {
+			Napi::Error::Fatal("", e.what());
+		}
+	}
+
+	self->unref();
+}
+
+Napi::Value Transfer::Cancel(const Napi::CallbackInfo& info){
+	ENTER_METHOD(Transfer, 0);
+	DEBUG_LOG("Cancel %p %i", self, !!self->transfer->buffer);
+	int r = libusb_cancel_transfer(self->transfer);
+	if (r == LIBUSB_ERROR_NOT_FOUND){
+		// Not useful to throw an error for this case
+		return Napi::Boolean::New(env, false);
+	} else {
+		CHECK_USB(r);
+		return Napi::Boolean::New(env, true);
+	}
+}
+
+Napi::Object Transfer::Init(Napi::Env env, Napi::Object exports) {
+	exports.Set("Transfer", Transfer::DefineClass(
+		env,
+		"Transfer",
+		{
+			Transfer::InstanceMethod("submit", &Transfer::Submit),
+			Transfer::InstanceMethod("cancel", &Transfer::Cancel),
+		}));
+
+	return exports;
+}

package/src/uv_async_queue.h

@@ -0,0 +1,33 @@
+#ifndef SRC_UV_ASYNC_QUEUE_H
+#define SRC_UV_ASYNC_QUEUE_H
+
+template <class T>
+class UVQueue{
+	public:
+		typedef void (*fptr)(T);
+
+		Napi::ThreadSafeFunction tsfn;
+
+		UVQueue(fptr cb): callback(cb)  {}
+
+		void start(Napi::Env env) {
+			Napi::Function empty_func = Napi::Function::New(env, [](const Napi::CallbackInfo& cb) {});
+			tsfn = Napi::ThreadSafeFunction::New(env, empty_func, "libusb", 0, 1);
+		}
+
+		void stop() {
+    		tsfn.Release();
+		}
+		
+		void post(T value){
+			auto cb = callback;
+			tsfn.BlockingCall( value, [cb](Napi::Env _env, Napi::Function _jsCallback, T val) {
+				cb(val);
+			});
+		}
+
+	private:
+		fptr callback;
+};
+
+#endif