usb 2.12.1 → 2.14.0

package/libusb/libusb/os/events_posix.c

@@ -28,6 +28,31 @@
 #ifdef HAVE_TIMERFD
 #include <sys/timerfd.h>
 #endif
+
+#ifdef __EMSCRIPTEN__
+/* On Emscripten `pipe` does not conform to the spec and does not block
+ * until events are available, which makes it unusable for event system
+ * and often results in deadlocks when `pipe` is in a loop like it is
+ * in libusb.
+ *
+ * Therefore use a custom event system based on browser event emitters. */
+#include <emscripten.h>
+#include <emscripten/atomic.h>
+#include <emscripten/threading.h>
+
+EM_ASYNC_JS(void, em_libusb_wait_async, (const _Atomic int* ptr, int expected_value, int timeout), {
+	await Atomics.waitAsync(HEAP32, ptr >> 2, expected_value, timeout).value;
+});
+
+static void em_libusb_wait(const _Atomic int *ptr, int expected_value, int timeout)
+{
+	if (emscripten_is_main_runtime_thread()) {
+		em_libusb_wait_async(ptr, expected_value, timeout);
+	} else {
+		emscripten_atomic_wait_u32((int*)ptr, expected_value, 1000000LL * timeout);
+	}
+}
+#endif
 #include <unistd.h>
 
 #ifdef HAVE_EVENTFD
@@ -131,6 +156,10 @@ void usbi_signal_event(usbi_event_t *event)
 	r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
 	if (r != sizeof(dummy))
 		usbi_warn(NULL, "event write failed");
+#ifdef __EMSCRIPTEN__
+	event->has_event = 1;
+	emscripten_atomic_notify(&event->has_event, EMSCRIPTEN_NOTIFY_ALL_WAITERS);
+#endif
 }
 
 void usbi_clear_event(usbi_event_t *event)
@@ -141,6 +170,9 @@ void usbi_clear_event(usbi_event_t *event)
 	r = read(EVENT_READ_FD(event), &dummy, sizeof(dummy));
 	if (r != sizeof(dummy))
 		usbi_warn(NULL, "event read failed");
+#ifdef __EMSCRIPTEN__
+	event->has_event = 0;
+#endif
 }
 
 #ifdef HAVE_TIMERFD
@@ -223,6 +255,14 @@ int usbi_wait_for_events(struct libusb_context *ctx,
 	int internal_fds, num_ready;
 
 	usbi_dbg(ctx, "poll() %u fds with timeout in %dms", (unsigned int)nfds, timeout_ms);
+#ifdef __EMSCRIPTEN__
+	// Emscripten's poll doesn't actually block, so we need to use an out-of-band
+	// waiting signal.
+	em_libusb_wait(&ctx->event.has_event, 0, timeout_ms);
+	// Emscripten ignores timeout_ms, but set it to 0 for future-proofing in case
+	// they ever implement real poll.
+	timeout_ms = 0;
+#endif
 	num_ready = poll(fds, nfds, timeout_ms);
 	usbi_dbg(ctx, "poll() returned %d", num_ready);
 	if (num_ready == 0) {

package/libusb/libusb/os/events_posix.h

@@ -36,6 +36,9 @@ typedef struct usbi_event {
 #else
 typedef struct usbi_event {
 	int pipefd[2];
+#ifdef __EMSCRIPTEN__
+	_Atomic int has_event;
+#endif
 } usbi_event_t;
 #define USBI_EVENT_OS_HANDLE(e)	((e)->pipefd[0])
 #define USBI_EVENT_POLL_EVENTS	POLLIN

package/libusb/libusb/os/linux_usbfs.c

@@ -95,9 +95,6 @@ static int sysfs_available = -1;
 /* how many times have we initted (and not exited) ? */
 static int init_count = 0;
 
-/* have no authority to operate usb device directly */
-static int no_enumeration = 0;
-
 /* Serialize scan-devices, event-thread, and poll */
 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
 
@@ -119,6 +116,11 @@ struct config_descriptor {
 	size_t actual_len;
 };
 
+struct linux_context_priv {
+	/* no enumeration or hot-plug detection */
+	int no_device_discovery;
+};
+
 struct linux_device_priv {
 	char *sysfs_dir;
 	void *descriptors;
@@ -187,10 +189,10 @@ static int get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
 	int fd;
 
 	if (usbdev_names)
-		sprintf(path, USBDEV_PATH "/usbdev%u.%u",
+		snprintf(path, sizeof(path), USBDEV_PATH "/usbdev%u.%u",
 			dev->bus_number, dev->device_address);
 	else
-		sprintf(path, USB_DEVTMPFS_PATH "/%03u/%03u",
+		snprintf(path, sizeof(path), USB_DEVTMPFS_PATH "/%03u/%03u",
 			dev->bus_number, dev->device_address);
 
 	fd = open(path, mode | O_CLOEXEC);
@@ -354,6 +356,7 @@ static int op_init(struct libusb_context *ctx)
 	struct kernel_version kversion;
 	const char *usbfs_path;
 	int r;
+	struct linux_context_priv *cpriv = usbi_get_context_priv(ctx);
 
 	if (get_kernel_version(ctx, &kversion) < 0)
 		return LIBUSB_ERROR_OTHER;
@@ -397,7 +400,7 @@ static int op_init(struct libusb_context *ctx)
 		}
 	}
 
-	if (no_enumeration) {
+	if (cpriv->no_device_discovery) {
 		return LIBUSB_SUCCESS;
 	}
 
@@ -421,9 +424,9 @@ static int op_init(struct libusb_context *ctx)
 
 static void op_exit(struct libusb_context *ctx)
 {
-	UNUSED(ctx);
+	struct linux_context_priv *cpriv = usbi_get_context_priv(ctx);
 
-	if (no_enumeration) {
+	if (cpriv->no_device_discovery) {
 		return;
 	}
 
@@ -436,12 +439,13 @@ static void op_exit(struct libusb_context *ctx)
 
 static int op_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap)
 {
-	UNUSED(ctx);
 	UNUSED(ap);
 
 	if (option == LIBUSB_OPTION_NO_DEVICE_DISCOVERY) {
-		usbi_dbg(ctx, "no enumeration will be performed");
-		no_enumeration = 1;
+		struct linux_context_priv *cpriv = usbi_get_context_priv(ctx);
+
+		usbi_dbg(ctx, "no device discovery will be performed");
+		cpriv->no_device_discovery = 1;
 		return LIBUSB_SUCCESS;
 	}
 
@@ -597,7 +601,7 @@ int linux_get_device_address(struct libusb_context *ctx, int detached,
 			char proc_path[32];
 
 			/* try to retrieve the device node from fd */
-			sprintf(proc_path, "/proc/self/fd/%d", fd);
+			snprintf(proc_path, sizeof(proc_path), "/proc/self/fd/%d", fd);
 			r = readlink(proc_path, fd_path, PATH_MAX - 1);
 			if (r > 0) {
 				fd_path[r] = '\0';
@@ -648,7 +652,7 @@ static int seek_to_next_config(struct libusb_context *ctx,
 
 	while (len > 0) {
 		if (len < 2) {
-			usbi_err(ctx, "short descriptor read %zu/2", len);
+			usbi_err(ctx, "remaining descriptor length too small %zu/2", len);
 			return LIBUSB_ERROR_IO;
 		}
 
@@ -656,6 +660,11 @@ static int seek_to_next_config(struct libusb_context *ctx,
 		if (header->bDescriptorType == LIBUSB_DT_CONFIG)
 			return offset;
 
+		if (header->bLength < 2) {
+			usbi_err(ctx, "invalid descriptor bLength %hhu", header->bLength);
+			return LIBUSB_ERROR_IO;
+		}
+
 		if (len < header->bLength) {
 			usbi_err(ctx, "bLength overflow by %zu bytes",
 				 (size_t)header->bLength - len);
@@ -1079,8 +1088,9 @@ retry:
 		goto retry;
 	}
 
-	usbi_dbg(ctx, "dev %p (%s) has parent %p (%s) port %u", dev, sysfs_dir,
-		 dev->parent_dev, parent_sysfs_dir, dev->port_number);
+	usbi_dbg(ctx, "dev %p (%s) has parent %p (%s) port %u",
+		 (void *) dev, sysfs_dir, (void *) dev->parent_dev,
+		 parent_sysfs_dir, dev->port_number);
 
 	free(parent_sysfs_dir);
 
@@ -1188,7 +1198,7 @@ static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
 	struct dirent *entry;
 	int r = LIBUSB_ERROR_IO;
 
-	sprintf(dirpath, USB_DEVTMPFS_PATH "/%03u", busnum);
+	snprintf(dirpath, sizeof(dirpath), USB_DEVTMPFS_PATH "/%03u", busnum);
 	usbi_dbg(ctx, "%s", dirpath);
 	dir = opendir(dirpath);
 	if (!dir) {
@@ -2801,6 +2811,7 @@ const struct usbi_os_backend usbi_backend = {
 
 	.handle_events = op_handle_events,
 
+	.context_priv_size = sizeof(struct linux_context_priv),
 	.device_priv_size = sizeof(struct linux_device_priv),
 	.device_handle_priv_size = sizeof(struct linux_device_handle_priv),
 	.transfer_priv_size = sizeof(struct linux_transfer_priv),

package/libusb/libusb/os/netbsd_usb.c

@@ -144,11 +144,11 @@ netbsd_get_device_list(struct libusb_context * ctx,
 		if (dev == NULL) {
 			dev = usbi_alloc_device(ctx, session_id);
 			if (dev == NULL)
-				return (LIBUSB_ERROR_NO_MEM);
+				return LIBUSB_ERROR_NO_MEM;
 
-			dev->bus_number = di.udi_bus;
-			dev->device_address = di.udi_addr;
-			dev->speed = di.udi_speed;
+			dev->bus_number = 1 + di.udi_bus;
+			dev->device_address = 1 + di.udi_addr;
+			dev->speed = di.udi_speed; /* NetBSD #define's happen to match libusb enum */
 
 			dpriv = usbi_get_device_priv(dev);
 			strlcpy(dpriv->devnode, devnode, sizeof(devnode));
@@ -175,12 +175,12 @@ netbsd_get_device_list(struct libusb_context * ctx,
 		close(fd);
 
 		if (discovered_devs_append(*discdevs, dev) == NULL)
-			return (LIBUSB_ERROR_NO_MEM);
+			return LIBUSB_ERROR_NO_MEM;
 
 		libusb_unref_device(dev);
 	}
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 
 error:
 	close(fd);
@@ -207,7 +207,7 @@ netbsd_open(struct libusb_device_handle *handle)
 
 	usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", dpriv->devnode, dpriv->fd);
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 void
@@ -259,7 +259,7 @@ netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
 	ufd.ufd_size = len;
 	ufd.ufd_data = buf;
 
-	if ((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
+	if (ioctl(fd, USB_GET_FULL_DESC, &ufd) < 0) {
 		err = errno;
 		if (dpriv->fd < 0)
 			close(fd);
@@ -286,7 +286,7 @@ netbsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
 	usbi_dbg(HANDLE_CTX(handle), "configuration %d", tmp);
 	*config = (uint8_t)tmp;
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 int
@@ -313,7 +313,7 @@ netbsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
 	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 		hpriv->endpoints[i] = -1;
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 int
@@ -328,7 +328,7 @@ netbsd_release_interface(struct libusb_device_handle *handle, uint8_t iface)
 		if (hpriv->endpoints[i] >= 0)
 			close(hpriv->endpoints[i]);
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 int
@@ -348,7 +348,7 @@ netbsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t ifa
 	if (ioctl(dpriv->fd, USB_SET_ALTINTERFACE, &intf) < 0)
 		return _errno_to_libusb(errno);
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 int
@@ -368,7 +368,7 @@ netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 	if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
 		return _errno_to_libusb(errno);
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 void
@@ -418,11 +418,11 @@ netbsd_submit_transfer(struct usbi_transfer *itransfer)
 	}
 
 	if (err)
-		return (err);
+		return err;
 
 	usbi_signal_transfer_completion(itransfer);
 
-	return (LIBUSB_SUCCESS);
+	return LIBUSB_SUCCESS;
 }
 
 int
@@ -432,7 +432,7 @@ netbsd_cancel_transfer(struct usbi_transfer *itransfer)
 
 	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
 
-	return (LIBUSB_ERROR_NOT_SUPPORTED);
+	return LIBUSB_ERROR_NOT_SUPPORTED;
 }
 
 int
@@ -446,21 +446,21 @@ _errno_to_libusb(int err)
 {
 	switch (err) {
 	case EIO:
-		return (LIBUSB_ERROR_IO);
+		return LIBUSB_ERROR_IO;
 	case EACCES:
-		return (LIBUSB_ERROR_ACCESS);
+		return LIBUSB_ERROR_ACCESS;
 	case ENOENT:
-		return (LIBUSB_ERROR_NO_DEVICE);
+		return LIBUSB_ERROR_NO_DEVICE;
 	case ENOMEM:
-		return (LIBUSB_ERROR_NO_MEM);
+		return LIBUSB_ERROR_NO_MEM;
 	case EWOULDBLOCK:
 	case ETIMEDOUT:
-		return (LIBUSB_ERROR_TIMEOUT);
+		return LIBUSB_ERROR_TIMEOUT;
 	}
 
-	usbi_dbg(NULL, "error: %s", strerror(err));
+	usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
 
-	return (LIBUSB_ERROR_OTHER);
+	return LIBUSB_ERROR_OTHER;
 }
 
 int
@@ -476,7 +476,7 @@ _cache_active_config_descriptor(struct libusb_device *dev, int fd)
 
 	ucd.ucd_config_index = USB_CURRENT_CONFIG_INDEX;
 
-	if ((ioctl(fd, USB_GET_CONFIG_DESC, &ucd)) < 0)
+	if (ioctl(fd, USB_GET_CONFIG_DESC, &ucd) < 0)
 		return _errno_to_libusb(errno);
 
 	usbi_dbg(DEVICE_CTX(dev), "active bLength %d", ucd.ucd_desc.bLength);
@@ -484,7 +484,7 @@ _cache_active_config_descriptor(struct libusb_device *dev, int fd)
 	len = UGETW(ucd.ucd_desc.wTotalLength);
 	buf = malloc((size_t)len);
 	if (buf == NULL)
-		return (LIBUSB_ERROR_NO_MEM);
+		return LIBUSB_ERROR_NO_MEM;
 
 	ufd.ufd_config_index = ucd.ucd_config_index;
 	ufd.ufd_size = len;
@@ -492,7 +492,7 @@ _cache_active_config_descriptor(struct libusb_device *dev, int fd)
 
 	usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", ufd.ufd_config_index, len);
 
-	if ((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
+	if (ioctl(fd, USB_GET_FULL_DESC, &ufd) < 0) {
 		free(buf);
 		return _errno_to_libusb(errno);
 	}
@@ -501,7 +501,7 @@ _cache_active_config_descriptor(struct libusb_device *dev, int fd)
 		free(dpriv->cdesc);
 	dpriv->cdesc = buf;
 
-	return (0);
+	return 0;
 }
 
 int
@@ -516,7 +516,7 @@ _sync_control_transfer(struct usbi_transfer *itransfer)
 	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
 	setup = (struct libusb_control_setup *)transfer->buffer;
 
-	usbi_dbg(ITRANSFER_CTX(itransfer), "type %d request %d value %d index %d length %d timeout %d",
+	usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d",
 	    setup->bmRequestType, setup->bRequest,
 	    libusb_le16_to_cpu(setup->wValue),
 	    libusb_le16_to_cpu(setup->wIndex),
@@ -533,17 +533,17 @@ _sync_control_transfer(struct usbi_transfer *itransfer)
 	if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
 		req.ucr_flags = USBD_SHORT_XFER_OK;
 
-	if ((ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+	if (ioctl(dpriv->fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
 		return _errno_to_libusb(errno);
 
-	if ((ioctl(dpriv->fd, USB_DO_REQUEST, &req)) < 0)
+	if (ioctl(dpriv->fd, USB_DO_REQUEST, &req) < 0)
 		return _errno_to_libusb(errno);
 
 	itransfer->transferred = req.ucr_actlen;
 
 	usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
 
-	return (0);
+	return 0;
 }
 
 int
@@ -572,12 +572,12 @@ _access_endpoint(struct libusb_transfer *transfer)
 		/* We may need to read/write to the same endpoint later. */
 		if (((fd = open(devnode, O_RDWR)) < 0) && (errno == ENXIO))
 			if ((fd = open(devnode, mode)) < 0)
-				return (-1);
+				return -1;
 
 		hpriv->endpoints[endpt] = fd;
 	}
 
-	return (hpriv->endpoints[endpt]);
+	return hpriv->endpoints[endpt];
 }
 
 int
@@ -595,12 +595,12 @@ _sync_gen_transfer(struct usbi_transfer *itransfer)
 	if ((fd = _access_endpoint(transfer)) < 0)
 		return _errno_to_libusb(errno);
 
-	if ((ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout)) < 0)
+	if (ioctl(fd, USB_SET_TIMEOUT, &transfer->timeout) < 0)
 		return _errno_to_libusb(errno);
 
 	if (IS_XFERIN(transfer)) {
 		if ((transfer->flags & LIBUSB_TRANSFER_SHORT_NOT_OK) == 0)
-			if ((ioctl(fd, USB_SET_SHORT_XFER, &nr)) < 0)
+			if (ioctl(fd, USB_SET_SHORT_XFER, &nr) < 0)
 				return _errno_to_libusb(errno);
 
 		nr = read(fd, transfer->buffer, transfer->length);
@@ -613,5 +613,5 @@ _sync_gen_transfer(struct usbi_transfer *itransfer)
 
 	itransfer->transferred = nr;
 
-	return (0);
+	return 0;
 }