usb 2.17.0 → 3.0.0-alpha.2

package/src/transfer.cc

@@ -1,143 +0,0 @@
-#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);
-    t->device->completionQueue.post(t);
-}
-
-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) {
-            e.ThrowAsJavaScriptException();
-        }
-    }
-
-    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

@@ -1,41 +0,0 @@
-#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 ref(Napi::Env env) {
-            tsfn.Ref(env);
-        }
-
-        void unref(Napi::Env env) {
-            tsfn.Unref(env);
-        }
-
-        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

package/test/usb.coffee

@@ -1,250 +0,0 @@
-assert = require('assert')
-util = require('util')
-usb = require('../').usb
-getDeviceList = require('../').getDeviceList
-findByIds = require('../').findByIds
-findBySerialNumber = require('../').findBySerialNumber
-Worker = require('worker_threads').Worker
-
-if typeof gc is 'function'
-    # running with --expose-gc, do a sweep between tests so valgrind blames the right one
-    afterEach -> gc()
-
-describe 'USB Module', ->
-    it 'should describe basic constants', ->
-        assert.notEqual(usb, undefined, "usb must be undefined")
-        assert.ok((usb.LIBUSB_CLASS_PER_INTERFACE != undefined), "Constants must be described")
-        assert.ok((usb.LIBUSB_ENDPOINT_IN == 128))
-
-    it 'should handle abuse without crashing', ->
-        assert.throws -> new usb.Device()
-        assert.throws -> usb.Device()
-        assert.throws -> usb.Device.prototype.open.call({})
-
-describe 'setDebugLevel', ->
-    it 'should throw when passed invalid args', ->
-        assert.throws((-> usb.setDebugLevel()), TypeError)
-        assert.throws((-> usb.setDebugLevel(-1)), TypeError)
-        assert.throws((-> usb.setDebugLevel(5)), TypeError)
-
-    it 'should succeed with good args', ->
-        assert.doesNotThrow(-> usb.setDebugLevel(0))
-
-describe 'getDeviceList', ->
-    it 'should return at least one device', ->
-        l = getDeviceList()
-        assert.ok((l.length > 0))
-
-describe 'findByIds', ->
-    it 'should return an array with length > 0', ->
-        dev = findByIds(0x59e3, 0x0a23)
-        assert.ok(dev, "Demo device is not attached")
-
-describe 'findBySerialNumber', ->
-    it 'should return a single device', ->
-        dev = findBySerialNumber('TEST_DEVICE')
-        assert.ok(dev, "Demo device is not attached")
-
-describe 'Hotplug', ->
-    it 'should detect detach', (done) ->
-        usb.once 'detach', (d) ->
-            assert.equal(d.deviceDescriptor.idVendor, 0x59e3)
-            assert.equal(d.deviceDescriptor.idProduct, 0x0a23)
-            done()
-        console.log('\n--- DISCONNECT DEVICE ---\n')
-
-    it 'should detect attach', (done) ->
-        usb.once 'attach', (d) ->
-            assert.equal(d.deviceDescriptor.idVendor, 0x59e3)
-            assert.equal(d.deviceDescriptor.idProduct, 0x0a23)
-            done()
-        console.log('\n--- CONNECT DEVICE ---\n')
-
-describe 'Device', ->
-    device = null
-    before ->
-        device = findByIds(0x59e3, 0x0a23)
-
-    it 'should have sane properties', ->
-        assert.ok((device.busNumber > 0), "busNumber must be larger than 0")
-        assert.ok((device.deviceAddress > 0), "deviceAddress must be larger than 0")
-        if process.platform != 'darwin' || process.arch != 'arm64'
-            assert.ok((util.isArray(device.portNumbers)), "portNumbers must be an array")
-
-    it 'should have a deviceDescriptor property', ->
-        assert.ok(((deviceDesc = device.deviceDescriptor) != undefined))
-
-    it 'should have a configDescriptor property', ->
-        assert.ok(device.configDescriptor != undefined)
-
-    it 'should open', ->
-        device.open()
-
-    it 'gets string descriptors', (done) ->
-        device.getStringDescriptor device.deviceDescriptor.iManufacturer, (e, s) ->
-            assert.ok(e == undefined, e)
-            assert.equal(s, 'Nonolith Labs')
-            done()
-
-    it 'supports null string descriptors', (done) ->
-        device.getStringDescriptor device.configDescriptor.iConfiguration, (e, s) ->
-            assert.ok(e == undefined, e)
-            assert.equal(s, undefined)
-            done()
-
-    describe 'control transfer', ->
-        b = Buffer.from([0x30...0x40])
-        it 'should OUT transfer when the IN bit is not set', (done) ->
-            device.controlTransfer 0x40, 0x81, 0, 0, b, (e) ->
-                assert.ok(e == undefined, e)
-                done()
-
-        it 'should fail when bmRequestType doesn\'t match buffer / length', ->
-            assert.throws(-> device.controlTransfer(0x40, 0x81, 0, 0, 64))
-
-        it 'should IN transfer when the IN bit is set', (done) ->
-            device.controlTransfer 0xc0, 0x81, 0, 0, 128, (e, d) ->
-                #console.log("ControlTransferIn", d, e)
-                assert.ok(e == undefined, e)
-                assert.equal(d.toString(), b.toString())
-                done()
-
-        it 'should signal errors', (done) ->
-            device.controlTransfer 0xc0, 0xff, 0, 0, 64, (e, d) ->
-                assert.equal e.errno, usb.LIBUSB_TRANSFER_STALL
-                done()
-
-    describe 'Interface', ->
-        iface = null
-        before ->
-            iface = device.interfaces[0]
-            iface.claim()
-
-        it 'should have one interface', ->
-            assert.notEqual(iface, undefined)
-
-        it 'should be the same as the interfaceNo 0', ->
-            assert.strictEqual iface, device.interface(0)
-
-        if process.platform == 'linux'
-            it "shouldn't have a kernel driver", ->
-                assert.equal iface.isKernelDriverActive(), false
-
-            it "should fail to detach the kernel driver", ->
-                assert.throws -> iface.detachKernelDriver()
-
-            it "should fail to attach the kernel driver", ->
-                assert.throws -> iface.attachKernelDriver()
-
-        describe 'IN endpoint', ->
-            inEndpoint = null
-            before ->
-                inEndpoint = iface.endpoints[0]
-
-            it 'should be able to get the endpoint', ->
-                assert.ok inEndpoint?
-
-            it 'should be able to get the endpoint by address', ->
-                assert.equal(inEndpoint, iface.endpoint(0x81))
-
-            it 'should have the IN direction flag', ->
-                assert.equal(inEndpoint.direction, 'in')
-
-            it 'should have a descriptor', ->
-                assert.equal(inEndpoint.descriptor.bEndpointAddress, 0x81)
-                assert.equal(inEndpoint.descriptor.wMaxPacketSize, 64)
-
-            it 'should fail to write', ->
-                assert.throws -> inEndpoint.transfer(b)
-
-            it 'should support read', (done) ->
-                inEndpoint.transfer 64, (e, d) ->
-                    assert.ok(e == undefined, e)
-                    assert.ok(d.length == 64)
-                    done()
-
-            it 'times out', (done) ->
-                iface.endpoints[2].timeout = 20
-                iface.endpoints[2].transfer 64, (e, d) ->
-                    assert.equal e.errno, usb.LIBUSB_TRANSFER_TIMED_OUT
-                    done()
-
-            it 'polls the device using events', (done) ->
-                pkts = 0
-
-                inEndpoint.startPoll 8, 64
-                inEndpoint.on 'data', (d) ->
-                    assert.equal d.length, 64
-                    pkts++
-
-                    if pkts == 100
-                        inEndpoint.stopPoll()
-
-                inEndpoint.once 'error', (e) ->
-                    throw e
-
-                inEndpoint.once 'end', ->
-                    done()
-
-            it 'polls the device using a callback', (done) ->
-                pkts = 0
-
-                inEndpoint.startPoll 8, 64, (e, b, a, c) ->
-                    assert.equal(c, true)
-                    assert.ok(e == undefined, e)
-                    assert.equal(pkts, 100)
-                    done()
-
-                inEndpoint.on 'data', (d) ->
-                    assert.equal d.length, 64
-                    pkts++
-
-                    if pkts == 100
-                        inEndpoint.stopPoll()
-
-                inEndpoint.once 'error', (e) ->
-                    throw e
-
-                inEndpoint.once 'end', ->
-                    assert.equal(pkts, 100)
-
-        describe 'OUT endpoint', ->
-            outEndpoint = null
-            before ->
-                outEndpoint = iface.endpoints[1]
-
-            it 'should be able to get the endpoint', ->
-                assert.ok outEndpoint?
-
-            it 'should be able to get the endpoint by address', ->
-                assert.equal(outEndpoint, iface.endpoint(0x02))
-
-            it 'should have the OUT direction flag', ->
-                assert.equal(outEndpoint.direction, 'out')
-
-            it 'should support write', (done) ->
-                outEndpoint.transfer [1,2,3,4], (e) ->
-                    assert.ok(e == undefined, e)
-                    done()
-
-            it 'times out', (done) ->
-                iface.endpoints[3].timeout = 20
-                iface.endpoints[3].transfer [1,2,3,4], (e) ->
-                    assert.equal e.errno, usb.LIBUSB_TRANSFER_TIMED_OUT
-                    done()
-
-        after (cb) ->
-            iface.release(cb)
-
-    after ->
-        device.close()
-
-if process.platform != 'win32'
-    describe 'Context Aware', ->
-        it 'should handle opening the same device from different contexts', ->
-            for n in [1..5]
-                worker = new Worker('./test/worker.cjs')
-                worker.on 'message', (serial) ->
-                    assert.equal(serial, 'TEST_DEVICE')
-                worker.on 'exit', (code) ->
-                    assert.equal(code, 0)

package/test/webusb.coffee

@@ -1,227 +0,0 @@
-assert = require('assert')
-util = require('util')
-webusb = require('../').webusb
-WebUSB = require('../').WebUSB
-
-if typeof gc is 'function'
-    # running with --expose-gc, do a sweep between tests so valgrind blames the right one
-    afterEach -> gc()
-
-describe 'WebUSB Module', ->
-    it 'should describe basic constants', ->
-        assert.notEqual(webusb, undefined, "webusb must be undefined")
-
-describe 'allowedDevices', ->
-    it 'should not list any devices by default', ->
-        l = await webusb.getDevices()
-        assert.equal(l.length, 0)
-
-    it 'should list allowed devices', ->
-        customWebusb = new WebUSB({ allowedDevices: [{ vendorId: 0x59e3 }] })
-        l = await customWebusb.getDevices()
-        assert.equal(l.length, 1)
-        assert.notEqual(l[0], undefined)
-
-describe 'requestDevice', ->
-    it 'should return a device', ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-        assert.notEqual(device, undefined)
-
-describe 'getDevices', ->
-    it 'should return one device', ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-        l = await webusb.getDevices()
-        assert.equal(l.length, 1)
-        assert.notEqual(l[0], undefined)
-        assert.deepEqual(l[0], device)
-
-describe 'WebUSB Hotplug', ->
-    it 'should detect disconnect', (done) ->
-        fn = (e) ->
-            assert.equal(e.device.serialNumber, "TEST_DEVICE")
-            webusb.removeEventListener 'disconnect', fn
-            done()
-        webusb.addEventListener 'disconnect', fn
-        console.log('\n--- DISCONNECT DEVICE ---\n')
-
-    it 'should detect connect', (done) ->
-        fn = (e) ->
-            assert.equal(e.device.serialNumber, "TEST_DEVICE")
-            webusb.removeEventListener 'connect', fn
-            done()
-        webusb.addEventListener 'connect', fn
-        console.log('\n--- CONNECT DEVICE ---\n')
-
-describe 'Device properties', ->
-    device = null
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-
-    it 'should have usb version properties', ->
-        assert.equal(device.usbVersionMajor, 1)
-        assert.equal(device.usbVersionMinor, 1)
-        assert.equal(device.usbVersionSubminor, 0)
-
-    it 'should have device version properties', ->
-        assert.equal(device.deviceVersionMajor, 1)
-        assert.equal(device.deviceVersionMinor, 1)
-        assert.equal(device.deviceVersionSubminor, 0)
-
-    it 'should have class properties', ->
-        assert.equal(device.deviceClass, 0)
-        assert.equal(device.deviceSubclass, 0)
-
-    it 'should have protocol property', ->
-        assert.equal(device.deviceProtocol, 0)
-
-    it 'should have vid/pid properties', ->
-        assert.equal(device.vendorId, 0x59e3)
-        assert.equal(device.productId, 0x0a23)
-
-    it 'should have a single configuration', ->
-        assert.equal(device.configurations.length, 1)
-        assert.equal(device.configurations[0].configurationValue, 1)
-
-    it 'should have a configuration property', ->
-        assert.notEqual(device.configuration, undefined)
-
-    it 'should have a single interface', ->
-        assert.equal(device.configuration.interfaces.length, 1)
-        assert.equal(device.configuration.interfaces[0].interfaceNumber, 0)
-
-    it 'should have a single alternate', ->
-        assert.equal(device.configuration.interfaces[0].alternates.length, 1)
-        assert.equal(device.configuration.interfaces[0].alternates[0].alternateSetting, 0)
-
-describe 'String descriptors', ->
-    device = null
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-
-    it 'gets serialNumber string', ->
-        assert.equal(device.serialNumber, "TEST_DEVICE")
-
-    it 'gets manufacturerName string', ->
-        assert.equal(device.manufacturerName, "Nonolith Labs")
-
-    it 'gets productName string', ->
-        assert.equal(device.productName, "STM32F103 Test Device")
-
-describe 'Device access', ->
-    device = null
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-
-    it 'is not open', ->
-        assert.equal(device.opened, false)
-
-    it 'is opens and closes', ->
-        assert.equal(device.opened, false)
-        await device.open()
-        assert.equal(device.opened, true)
-        await device.close()
-        assert.equal(device.opened, false)
-
-describe 'Configurations', ->
-    device = null
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-        await device.open()
-
-    it 'selects existing configuration', ->
-        assert.doesNotReject(device.selectConfiguration(1))
-
-    it 'fails to select missing configuration', ->
-        assert.rejects(device.selectConfiguration(99))
-
-    after ->
-        device.close()
-
-describe 'Interfaces', ->
-    device = null
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-        await device.open()
-
-    it 'claims existing interface', ->
-        assert.doesNotReject(device.claimInterface(0))
-
-    it 'fails to claim missing interface', ->
-        assert.rejects(device.claimInterface(99))
-
-    it 'releases existing interface', ->
-        assert.doesNotReject(device.releaseInterface(0))
-
-    it 'fails to release missing interface', ->
-        assert.rejects(device.releaseInterface(99))
-
-    after ->
-        device.close()
-
-describe 'Alternates', ->
-    device = null
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-        await device.open()
-        await device.claimInterface(0)
-
-    it 'selects existing alternate', ->
-        assert.doesNotReject(device.selectAlternateInterface(0, 0))
-
-    after ->
-        device.close()
-
-describe 'Throwing Transfers', ->
-    device = null
-
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-
-    it 'should fail transfer unless opened', ->
-        assert.rejects(device.transferIn(1, 64), 'The device must be opened first')
-
-describe 'Transfers', ->
-    device = null
-    b = Uint8Array.from([0x30...0x40]).buffer
-
-    before ->
-        device = await webusb.requestDevice({ filters: [{ vendorId: 0x59e3 }] });
-        await device.open()
-        await device.claimInterface(0)
-
-    it 'should control transfer OUT', ->
-        transferResult = await device.controlTransferOut({
-            requestType: 'device',
-            recipient: 'vendor',
-            request: 0x81,
-            value: 0,
-            index: 0
-        }, b)
-
-        assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.bytesWritten, b.byteLength)
-
-    it 'should control transfer IN', ->
-        transferResult = await device.controlTransferIn({
-            requestType: 'device',
-            recipient: 'vendor',
-            request: 0x81,
-            value: 0,
-            index: 0
-        }, 128)
-
-        assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.data.buffer.toString(), b.toString())
-
-    it 'should transfer OUT', ->
-        transferResult = await device.transferOut(2, b)
-        assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.bytesWritten, b.byteLength)
-
-    it 'should transfer IN', ->
-        transferResult = await device.transferIn(1, 64)
-        assert.equal(transferResult.status, 'ok')
-        assert.equal(transferResult.data.byteLength, 64)
-
-    after ->
-        device.close()

package/test/worker.cjs

@@ -1,13 +0,0 @@
-const parentPort = require('worker_threads').parentPort
-const findByIds = require('../dist').findByIds;
-
-const device = findByIds(0x59e3, 0x0a23);
-if (!device) {
-    console.error('No test device connected, tests require this device to be present');
-    return;
-}
-device.open();
-device.getStringDescriptor(device.deviceDescriptor.iSerialNumber, (_, serial) => {
-    parentPort?.postMessage(serial);
-    device.close();
-});