usb 2.1.1 → 2.2.0

package/libusb/tests/testlib.c

@@ -17,43 +17,26 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libusb_testlib.h"
+#include <config.h>
 
-#include <stdio.h>
+#include <errno.h>
 #include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
 #include <string.h>
-#include <errno.h>
-#if !defined(_WIN32_WCE)
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#endif
 
-#if defined(_WIN32_WCE)
-// No support for selective redirection of STDOUT on WinCE.
-#define DISABLE_STDOUT_REDIRECTION
-#define STDOUT_FILENO 1
-#elif defined(_WIN32)
-#include <io.h>
-#define dup _dup
-#define dup2 _dup2
-#define open _open
-#define close _close
-#define fdopen _fdopen
-#define NULL_PATH "nul"
-#define STDOUT_FILENO 1
-#define STDERR_FILENO 2
-#else
-#include <unistd.h>
+#include "libusb_testlib.h"
+
+#if defined(PLATFORM_POSIX)
 #define NULL_PATH "/dev/null"
+#elif defined(PLATFORM_WINDOWS)
+#define NULL_PATH "nul"
 #endif
-#define INVALID_FD -1
-#define IGNORE_RETVAL(expr) do { (void)(expr); } while(0)
 
 /**
  * Converts a test result code into a human readable string.
  */
-static const char* test_result_to_str(libusb_testlib_result result)
+static const char *test_result_to_str(libusb_testlib_result result)
 {
 	switch (result) {
 	case TEST_STATUS_SUCCESS:
@@ -69,100 +52,27 @@ static const char* test_result_to_str(libusb_testlib_result result)
 	}
 }
 
-static void print_usage(int argc, char ** argv)
+static void print_usage(const char *progname)
 {
-	printf("Usage: %s [-l] [-v] [<test_name> ...]\n",
-		argc > 0 ? argv[0] : "test_*");
+	printf("Usage: %s [-l] [-v] [<test_name> ...]\n", progname);
 	printf("   -l   List available tests\n");
-	printf("   -v   Don't redirect STDERR/STDOUT during tests\n");
+	printf("   -v   Don't redirect STDERR before running tests\n");
+	printf("   -h   Display this help and exit\n");
 }
 
-static void cleanup_test_output(libusb_testlib_ctx * ctx)
-{
-#ifndef DISABLE_STDOUT_REDIRECTION
-	if (!ctx->verbose) {
-		if (ctx->old_stdout != INVALID_FD) {
-			IGNORE_RETVAL(dup2(ctx->old_stdout, STDOUT_FILENO));
-			ctx->old_stdout = INVALID_FD;
-		}
-		if (ctx->old_stderr != INVALID_FD) {
-			IGNORE_RETVAL(dup2(ctx->old_stderr, STDERR_FILENO));
-			ctx->old_stderr = INVALID_FD;
-		}
-		if (ctx->null_fd != INVALID_FD) {
-			close(ctx->null_fd);
-			ctx->null_fd = INVALID_FD;
-		}
-		if (ctx->output_file != stdout) {
-			fclose(ctx->output_file);
-			ctx->output_file = stdout;
-		}
-	}
-#endif
-}
-
-/**
- * Setup test output handles
- * \return zero on success, non-zero on failure
- */
-static int setup_test_output(libusb_testlib_ctx * ctx)
-{
-#ifndef DISABLE_STDOUT_REDIRECTION
-	/* Stop output to stdout and stderr from being displayed if using non-verbose output */
-	if (!ctx->verbose) {
-		/* Keep a copy of STDOUT and STDERR */
-		ctx->old_stdout = dup(STDOUT_FILENO);
-		if (ctx->old_stdout < 0) {
-			ctx->old_stdout = INVALID_FD;
-			printf("Failed to duplicate stdout handle: %d\n", errno);
-			return 1;
-		}
-		ctx->old_stderr = dup(STDERR_FILENO);
-		if (ctx->old_stderr < 0) {
-			ctx->old_stderr = INVALID_FD;
-			cleanup_test_output(ctx);
-			printf("Failed to duplicate stderr handle: %d\n", errno);
-			return 1;
-		}
-		/* Redirect STDOUT_FILENO and STDERR_FILENO to /dev/null or "nul"*/
-		ctx->null_fd = open(NULL_PATH, O_WRONLY);
-		if (ctx->null_fd < 0) {
-			ctx->null_fd = INVALID_FD;
-			cleanup_test_output(ctx);
-			printf("Failed to open null handle: %d\n", errno);
-			return 1;
-		}
-		if ((dup2(ctx->null_fd, STDOUT_FILENO) < 0) ||
-			(dup2(ctx->null_fd, STDERR_FILENO) < 0)) {
-				cleanup_test_output(ctx);
-				return 1;
-		}
-		ctx->output_file = fdopen(ctx->old_stdout, "w");
-		if (!ctx->output_file) {
-			ctx->output_file = stdout;
-			cleanup_test_output(ctx);
-			printf("Failed to open FILE for output handle: %d\n", errno);
-			return 1;
-		}
-	}
-#endif
-	return 0;
-}
-
-void libusb_testlib_logf(libusb_testlib_ctx * ctx,
-	const char* fmt, ...)
+void libusb_testlib_logf(const char *fmt, ...)
 {
 	va_list va;
+
 	va_start(va, fmt);
-	vfprintf(ctx->output_file, fmt, va);
+	vfprintf(stdout, fmt, va);
 	va_end(va);
-	fprintf(ctx->output_file, "\n");
-	fflush(ctx->output_file);
+	fputc('\n', stdout);
+	fflush(stdout);
 }
 
-int libusb_testlib_run_tests(int argc,
-	char ** argv,
-	const libusb_testlib_test * tests)
+int libusb_testlib_run_tests(int argc, char *argv[],
+	const libusb_testlib_test *tests)
 {
 	int run_count = 0;
 	int idx = 0;
@@ -170,108 +80,105 @@ int libusb_testlib_run_tests(int argc,
 	int fail_count = 0;
 	int error_count = 0;
 	int skip_count = 0;
-	int r, j;
-	size_t arglen;
-	libusb_testlib_result test_result;
-	libusb_testlib_ctx ctx;
 
 	/* Setup default mode of operation */
-	ctx.test_names = NULL;
-	ctx.test_count = 0;
-	ctx.list_tests = false;
-	ctx.verbose = false;
-	ctx.old_stdout = INVALID_FD;
-	ctx.old_stderr = INVALID_FD;
-	ctx.output_file = stdout;
-	ctx.null_fd = INVALID_FD;
+	char **test_names = NULL;
+	int test_count = 0;
+	bool list_tests = false;
+	bool verbose = false;
 
 	/* Parse command line options */
 	if (argc >= 2) {
-		for (j = 1; j < argc; j++) {
-			arglen = strlen(argv[j]);
-			if ( ((argv[j][0] == '-') || (argv[j][0] == '/')) &&
-				arglen >=2 ) {
-					switch (argv[j][1]) {
+		for (int j = 1; j < argc; j++) {
+			const char *argstr = argv[j];
+			size_t arglen = strlen(argstr);
+
+			if (argstr[0] == '-' || argstr[0] == '/') {
+				if (arglen == 2) {
+					switch (argstr[1]) {
 					case 'l':
-						ctx.list_tests = true;
-						break;
+						list_tests = true;
+						continue;
 					case 'v':
-						ctx.verbose = true;
-						break;
-					default:
-						printf("Unknown option: '%s'\n", argv[j]);
-						print_usage(argc, argv);
-						return 1;
+						verbose = true;
+						continue;
+					case 'h':
+						print_usage(argv[0]);
+						return 0;
 					}
+				}
+
+				fprintf(stderr, "Unknown option: '%s'\n", argstr);
+				print_usage(argv[0]);
+				return 1;
 			} else {
 				/* End of command line options, remaining must be list of tests to run */
-				ctx.test_names = argv + j;
-				ctx.test_count = argc - j;
+				test_names = argv + j;
+				test_count = argc - j;
 				break;
 			}
 		}
 	}
 
 	/* Validate command line options */
-	if (ctx.test_names && ctx.list_tests) {
-		printf("List of tests requested but test list provided\n");
-		print_usage(argc, argv);
+	if (test_names && list_tests) {
+		fprintf(stderr, "List of tests requested but test list provided\n");
+		print_usage(argv[0]);
 		return 1;
 	}
 
 	/* Setup test log output */
-	r = setup_test_output(&ctx);
-	if (r != 0)
-		return r;  
+	if (!verbose) {
+		if (!freopen(NULL_PATH, "w", stderr)) {
+			printf("Failed to open null handle: %d\n", errno);
+			return 1;
+		}
+	}
 
 	/* Act on any options not related to running tests */
-	if (ctx.list_tests) {
-		while (tests[idx].function != NULL) {
-			libusb_testlib_logf(&ctx, tests[idx].name);
-			++idx;
-		}
-		cleanup_test_output(&ctx);
+	if (list_tests) {
+		while (tests[idx].function)
+			libusb_testlib_logf("%s", tests[idx++].name);
 		return 0;
 	}
 
 	/* Run any requested tests */
-	while (tests[idx].function != NULL) {
-		const libusb_testlib_test * test = &tests[idx];
-		++idx;
-		if (ctx.test_count > 0) {
+	while (tests[idx].function) {
+		const libusb_testlib_test *test = &tests[idx++];
+		libusb_testlib_result test_result;
+
+		if (test_count > 0) {
 			/* Filtering tests to run, check if this is one of them */
 			int i;
-			for (i = 0; i < ctx.test_count; ++i) {
-				if (strcmp(ctx.test_names[i], test->name) == 0)
+
+			for (i = 0; i < test_count; i++) {
+				if (!strcmp(test_names[i], test->name))
 					/* Matches a requested test name */
 					break;
 			}
-			if (i >= ctx.test_count) {
+			if (i == test_count) {
 				/* Failed to find a test match, so do the next loop iteration */
 				continue;
 			}
 		}
-		libusb_testlib_logf(&ctx,
-			"Starting test run: %s...", test->name);
-		test_result = test->function(&ctx);
-		libusb_testlib_logf(&ctx,
-			"%s (%d)",
-			test_result_to_str(test_result), test_result);
+		libusb_testlib_logf("Starting test run: %s...", test->name);
+		test_result = test->function();
+		libusb_testlib_logf("%s (%d)", test_result_to_str(test_result), test_result);
 		switch (test_result) {
 		case TEST_STATUS_SUCCESS: pass_count++; break;
 		case TEST_STATUS_FAILURE: fail_count++; break;
 		case TEST_STATUS_ERROR: error_count++; break;
 		case TEST_STATUS_SKIP: skip_count++; break;
 		}
-		++run_count;
+		run_count++;
 	}
-	libusb_testlib_logf(&ctx, "---");
-	libusb_testlib_logf(&ctx, "Ran %d tests", run_count);
-	libusb_testlib_logf(&ctx, "Passed %d tests", pass_count);
-	libusb_testlib_logf(&ctx, "Failed %d tests", fail_count);
-	libusb_testlib_logf(&ctx, "Error in %d tests", error_count);
-	libusb_testlib_logf(&ctx, "Skipped %d tests", skip_count);
 
-	cleanup_test_output(&ctx);
+	libusb_testlib_logf("---");
+	libusb_testlib_logf("Ran %d tests", run_count);
+	libusb_testlib_logf("Passed %d tests", pass_count);
+	libusb_testlib_logf("Failed %d tests", fail_count);
+	libusb_testlib_logf("Error in %d tests", error_count);
+	libusb_testlib_logf("Skipped %d tests", skip_count);
+
 	return pass_count != run_count;
 }

package/libusb.gypi

@@ -15,14 +15,13 @@
         'libusb/libusb/core.c',
         'libusb/libusb/descriptor.c',
         'libusb/libusb/hotplug.c',
-        'libusb/libusb/hotplug.h',
         'libusb/libusb/io.c',
         'libusb/libusb/libusb.h',
         'libusb/libusb/libusbi.h',
         'libusb/libusb/strerror.c',
         'libusb/libusb/sync.c',
-        'libusb/libusb/version.h',
         'libusb/libusb/version_nano.h',
+        'libusb/libusb/version.h',
       ],
       'include_dirs': [
         'libusb_config',
@@ -43,8 +42,8 @@
       'conditions': [
         [ 'OS == "linux" or OS == "android" or OS == "mac"', {
           'sources': [
-            'libusb/libusb/os/poll_posix.c',
-            'libusb/libusb/os/poll_posix.h',
+            'libusb/libusb/os/events_posix.c',
+            'libusb/libusb/os/events_posix.h',
             'libusb/libusb/os/threads_posix.c',
             'libusb/libusb/os/threads_posix.h',
           ],
@@ -105,6 +104,10 @@
           'sources': [
             'libusb/libusb/os/darwin_usb.c',
             'libusb/libusb/os/darwin_usb.h',
+            'libusb/Xcode/config.h',
+          ],
+          'include_dirs': [
+            'libusb/Xcode',
           ],
           'defines': [
             'OS_DARWIN=1',
@@ -120,21 +123,17 @@
         }],
         [ 'OS == "win"', {
           'sources': [
-            'libusb/libusb/os/poll_windows.c',
-            'libusb/libusb/os/poll_windows.h',
+            'libusb/libusb/os/events_windows.c',
+            'libusb/libusb/os/events_windows.h',
             'libusb/libusb/os/threads_windows.c',
             'libusb/libusb/os/threads_windows.h',
+            'libusb/libusb/os/windows_common.c',
             'libusb/libusb/os/windows_common.h',
-            'libusb/libusb/os/windows_nt_common.c',
-            'libusb/libusb/os/windows_nt_common.h',
-            'libusb/libusb/os/windows_nt_shared_types.h',
             'libusb/libusb/os/windows_usbdk.c',
             'libusb/libusb/os/windows_usbdk.h',
             'libusb/libusb/os/windows_winusb.c',
             'libusb/libusb/os/windows_winusb.h',
             'libusb/msvc/config.h',
-            'libusb/msvc/inttypes.h',
-            'libusb/msvc/stdint.h',
           ],
           'include_dirs!': [
             'libusb_config',

package/package.json

@@ -2,7 +2,7 @@
   "name": "usb",
   "description": "Library to access USB devices",
   "license": "MIT",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "main": "dist/index.js",
   "engines": {
     "node": ">=10.16.0"
@@ -52,7 +52,7 @@
     "prebuild-download": "prebuildify-ci download"
   },
   "dependencies": {
-    "@types/w3c-web-usb": "^1.0.4",
+    "@types/w3c-web-usb": "1.0.6",
     "node-addon-api": "^4.2.0",
     "node-gyp-build": "^4.3.0"
   },

package/src/device.cc

@@ -18,14 +18,16 @@ Device::Device(const Napi::CallbackInfo & info) : Napi::ObjectWrap<Device>(info)
 {
 	device = info[0].As<Napi::External<libusb_device>>().Data();
 	libusb_ref_device(device);
-	byPtr.insert(std::make_pair(device, this));
+	byPtr[device] = this;
 	DEBUG_LOG("Created device %p", this);
 	Constructor(info);
 }
 
 Device::~Device(){
 	DEBUG_LOG("Freed device %p", this);
-	byPtr.erase(device);
+	auto it = byPtr.find(device);
+	if (it != byPtr.end() && it->second == this)
+		byPtr.erase(it);
 	libusb_close(device_handle);
 	libusb_unref_device(device);
 }
@@ -37,12 +39,15 @@ std::map<libusb_device*, Device*> Device::byPtr;
 // 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;
+	if (it != byPtr.end()) {
+		auto value = it->second->Value();
+		// JS object may have already been garbage collected
+		if (!value.IsEmpty())
+			return value;
 	}
+
+	Napi::Object obj = Device::constructor.New({ Napi::External<libusb_device>::New(env, dev) });
+	return obj;
 }
 
 Napi::Value Device::Constructor(const Napi::CallbackInfo& info) {

package/src/node_usb.cc

@@ -3,6 +3,7 @@
 #include <thread>
 
 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 EnableHotplugEvents(const Napi::CallbackInfo& info);
@@ -97,6 +98,7 @@ Napi::Object Init(Napi::Env env, Napi::Object 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("_enableHotplugEvents", Napi::Function::New(env, EnableHotplugEvents));
@@ -119,6 +121,14 @@ Napi::Value SetDebugLevel(const Napi::CallbackInfo& info) {
 	return env.Undefined();
 }
 
+Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
+	Napi::HandleScope scope(env);
+
+	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);

package/test/usb.coffee

@@ -70,6 +70,12 @@ describe 'Device', ->
 			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) ->

package/tsc/index.ts

@@ -5,6 +5,7 @@ import * as usb from './usb';
 
 const webusb = new WebUSB();
 const getDeviceList = usb.getDeviceList;
+const useUsbDkBackend = usb.useUsbDkBackend;
 
 /**
  * Convenience method to get the first device with the specified VID and PID, or `undefined` if no such device is present.
@@ -57,6 +58,7 @@ export {
     usb,
 
     // Convenience methods
+    useUsbDkBackend,
     getDeviceList,
     findByIds,
     findBySerialNumber,

package/tsc/usb/bindings.ts

@@ -26,6 +26,11 @@ export declare class LibUSBException extends Error {
  */
 export declare function setDebugLevel(level: number): void;
 
+/**
+ * Use USBDK Backend (Windows only)
+ */
+export declare function useUsbDkBackend(): void;
+
 export declare function _enableHotplugEvents(): void;
 export declare function _disableHotplugEvents(): void;
 export declare function _getLibusbCapability(capability: number): number;

package/tsc/usb/device.ts

@@ -203,6 +203,12 @@ export class ExtendedDevice {
      * @param callback
      */
     public getStringDescriptor(this: usb.Device, desc_index: number, callback: (error?: usb.LibUSBException, value?: string) => void): void {
+        // Index 0 indicates null
+        if (desc_index === 0) {
+            callback();
+            return;
+        }
+
         const langid = 0x0409;
         const length = 255;
         this.controlTransfer(

package/tsc/usb/interface.ts

@@ -161,12 +161,7 @@ export class Interface {
      * The device must be open to use this method.
      * @param addr
      */
-    public endpoint(addr: number): Endpoint {
-        const endpoint = this.endpoints.find(item => item.address === addr);
-        if (!endpoint) {
-            throw new Error(`Endpoint not found for address: ${addr}`);
-        }
-
-        return endpoint;
+    public endpoint(addr: number): Endpoint | undefined {
+        return this.endpoints.find(item => item.address === addr);
     }
 }

package/tsc/webusb/webusb-device.ts

@@ -368,14 +368,6 @@ export class WebUSBDevice implements USBDevice {
         }
     }
 
-    public async isochronousTransferIn(_endpointNumber: number, _packetLengths: number[]): Promise<USBIsochronousInTransferResult> {
-        throw new Error('isochronousTransferIn error: method not implemented');
-    }
-
-    public async isochronousTransferOut(_endpointNumber: number, _data: BufferSource, _packetLengths: number[]): Promise<USBIsochronousOutTransferResult> {
-        throw new Error('isochronousTransferOut error: method not implemented');
-    }
-
     public async reset(): Promise<void> {
         try {
             await this.deviceMutex.lock();
@@ -388,6 +380,18 @@ export class WebUSBDevice implements USBDevice {
         }
     }
 
+    public async isochronousTransferIn(_endpointNumber: number, _packetLengths: number[]): Promise<USBIsochronousInTransferResult> {
+        throw new Error('isochronousTransferIn error: method not implemented');
+    }
+
+    public async isochronousTransferOut(_endpointNumber: number, _data: BufferSource, _packetLengths: number[]): Promise<USBIsochronousOutTransferResult> {
+        throw new Error('isochronousTransferOut error: method not implemented');
+    }
+
+    public async forget(): Promise<void> {
+        throw new Error('forget error: method not implemented');
+    }
+
     private async initialize(): Promise<void> {
         try {
             await this.deviceMutex.lock();