usb 2.1.2 → 2.3.0

package/libusb/libusb/os/darwin_usb.h

@@ -30,59 +30,63 @@
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/IOCFPlugIn.h>
 
+#if defined(HAVE_IOKIT_USB_IOUSBHOSTFAMILYDEFINITIONS_H)
+#include <IOKit/usb/IOUSBHostFamilyDefinitions.h>
+#endif
+
 /* IOUSBInterfaceInferface */
 
 /* New in OS 10.12.0. */
-#if defined (kIOUSBInterfaceInterfaceID800) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
+#if defined (kIOUSBInterfaceInterfaceID800)
 
 #define usb_interface_t IOUSBInterfaceInterface800
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID800
 #define InterfaceVersion 800
 
 /* New in OS 10.10.0. */
-#elif defined (kIOUSBInterfaceInterfaceID700) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 101000)
+#elif defined (kIOUSBInterfaceInterfaceID700)
 
 #define usb_interface_t IOUSBInterfaceInterface700
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID700
 #define InterfaceVersion 700
 
 /* New in OS 10.9.0. */
-#elif defined (kIOUSBInterfaceInterfaceID650) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
+#elif defined (kIOUSBInterfaceInterfaceID650)
 
 #define usb_interface_t IOUSBInterfaceInterface650
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID650
 #define InterfaceVersion 650
 
 /* New in OS 10.8.2 but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBInterfaceInterfaceID550) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
+#elif defined (kIOUSBInterfaceInterfaceID550)
 
 #define usb_interface_t IOUSBInterfaceInterface550
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID550
 #define InterfaceVersion 550
 
 /* New in OS 10.7.3 but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBInterfaceInterfaceID500) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1080)
+#elif defined (kIOUSBInterfaceInterfaceID500)
 
 #define usb_interface_t IOUSBInterfaceInterface500
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID500
 #define InterfaceVersion 500
 
 /* New in OS 10.5.0. */
-#elif defined (kIOUSBInterfaceInterfaceID300) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+#elif defined (kIOUSBInterfaceInterfaceID300)
 
 #define usb_interface_t IOUSBInterfaceInterface300
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID300
 #define InterfaceVersion 300
 
 /* New in OS 10.4.5 (or 10.4.6?) but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBInterfaceInterfaceID245) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+#elif defined (kIOUSBInterfaceInterfaceID245)
 
 #define usb_interface_t IOUSBInterfaceInterface245
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID245
 #define InterfaceVersion 245
 
 /* New in OS 10.4.0. */
-#elif defined (kIOUSBInterfaceInterfaceID220) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1040)
+#elif defined (kIOUSBInterfaceInterfaceID220)
 
 #define usb_interface_t IOUSBInterfaceInterface220
 #define InterfaceInterfaceID kIOUSBInterfaceInterfaceID220
@@ -97,42 +101,42 @@
 /* IOUSBDeviceInterface */
 
 /* New in OS 10.9.0. */
-#if defined (kIOUSBDeviceInterfaceID650) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
+#if defined (kIOUSBDeviceInterfaceID650)
 
 #define usb_device_t    IOUSBDeviceInterface650
 #define DeviceInterfaceID kIOUSBDeviceInterfaceID650
 #define DeviceVersion 650
 
 /* New in OS 10.7.3 but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBDeviceInterfaceID500) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1080)
+#elif defined (kIOUSBDeviceInterfaceID500)
 
 #define usb_device_t    IOUSBDeviceInterface500
 #define DeviceInterfaceID kIOUSBDeviceInterfaceID500
 #define DeviceVersion 500
 
 /* New in OS 10.5.4 but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBDeviceInterfaceID320) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1060)
+#elif defined (kIOUSBDeviceInterfaceID320)
 
 #define usb_device_t    IOUSBDeviceInterface320
 #define DeviceInterfaceID kIOUSBDeviceInterfaceID320
 #define DeviceVersion 320
 
 /* New in OS 10.5.0. */
-#elif defined (kIOUSBDeviceInterfaceID300) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+#elif defined (kIOUSBDeviceInterfaceID300)
 
 #define usb_device_t    IOUSBDeviceInterface300
 #define DeviceInterfaceID kIOUSBDeviceInterfaceID300
 #define DeviceVersion 300
 
 /* New in OS 10.4.5 (or 10.4.6?) but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBDeviceInterfaceID245) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
+#elif defined (kIOUSBDeviceInterfaceID245)
 
 #define usb_device_t    IOUSBDeviceInterface245
 #define DeviceInterfaceID kIOUSBDeviceInterfaceID245
 #define DeviceVersion 245
 
 /* New in OS 10.2.3 but can't test deployment target to that granularity, so round up. */
-#elif defined (kIOUSBDeviceInterfaceID197) && (MAC_OS_X_VERSION_MIN_REQUIRED >= 1030)
+#elif defined (kIOUSBDeviceInterfaceID197)
 
 #define usb_device_t    IOUSBDeviceInterface197
 #define DeviceInterfaceID kIOUSBDeviceInterfaceID197
@@ -144,10 +148,28 @@
 
 #endif
 
+#if !defined(kIOUSBHostInterfaceClassName)
+#define kIOUSBHostInterfaceClassName "IOUSBHostInterface"
+#endif
+
+#if !defined(kUSBHostMatchingPropertyInterfaceNumber)
+#define kUSBHostMatchingPropertyInterfaceNumber "bInterfaceNumber"
+#endif
+
 #if !defined(IO_OBJECT_NULL)
 #define IO_OBJECT_NULL ((io_object_t) 0)
 #endif
 
+/* Testing availability */
+#ifndef __has_builtin
+  #define __has_builtin(x) 0  // Compatibility with non-clang compilers.
+#endif
+#if __has_builtin(__builtin_available)
+  #define HAS_CAPTURE_DEVICE() __builtin_available(macOS 10.10, *)
+#else
+  #define HAS_CAPTURE_DEVICE() 0
+#endif
+
 typedef IOCFPlugInInterface *io_cf_plugin_ref_t;
 typedef IONotificationPortRef io_notification_port_t;
 
@@ -161,11 +183,13 @@ struct darwin_cached_device {
   USBDeviceAddress      address;
   char                  sys_path[21];
   usb_device_t        **device;
+  io_service_t          service;
   int                   open_count;
-  UInt8                 first_config, active_config, port;  
+  UInt8                 first_config, active_config, port;
   int                   can_enumerate;
   int                   refcount;
   bool                  in_reenumerate;
+  int                   capture_count;
 };
 
 struct darwin_device_priv {

package/libusb/libusb/os/events_posix.c

@@ -0,0 +1,300 @@
+/*
+ * libusb event abstraction on POSIX platforms
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libusbi.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#ifdef HAVE_EVENTFD
+#include <sys/eventfd.h>
+#endif
+#ifdef HAVE_TIMERFD
+#include <sys/timerfd.h>
+#endif
+#include <unistd.h>
+
+#ifdef HAVE_EVENTFD
+#define EVENT_READ_FD(e)	((e)->eventfd)
+#define EVENT_WRITE_FD(e)	((e)->eventfd)
+#else
+#define EVENT_READ_FD(e)	((e)->pipefd[0])
+#define EVENT_WRITE_FD(e)	((e)->pipefd[1])
+#endif
+
+#ifdef HAVE_NFDS_T
+typedef nfds_t usbi_nfds_t;
+#else
+typedef unsigned int usbi_nfds_t;
+#endif
+
+int usbi_create_event(usbi_event_t *event)
+{
+#ifdef HAVE_EVENTFD
+	event->eventfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
+	if (event->eventfd == -1) {
+		usbi_err(NULL, "failed to create eventfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+#else
+#if defined(HAVE_PIPE2)
+	int ret = pipe2(event->pipefd, O_CLOEXEC);
+#else
+	int ret = pipe(event->pipefd);
+#endif
+
+	if (ret != 0) {
+		usbi_err(NULL, "failed to create pipe, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
+	ret = fcntl(event->pipefd[0], F_GETFD);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(event->pipefd[0], F_SETFD, ret | FD_CLOEXEC);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+
+	ret = fcntl(event->pipefd[1], F_GETFD);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(event->pipefd[1], F_SETFD, ret | FD_CLOEXEC);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+#endif
+
+	ret = fcntl(event->pipefd[1], F_GETFL);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to get pipe fd status flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+	ret = fcntl(event->pipefd[1], F_SETFL, ret | O_NONBLOCK);
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set pipe fd status flags, errno=%d", errno);
+		goto err_close_pipe;
+	}
+
+	return 0;
+
+err_close_pipe:
+	close(event->pipefd[1]);
+	close(event->pipefd[0]);
+	return LIBUSB_ERROR_OTHER;
+#endif
+}
+
+void usbi_destroy_event(usbi_event_t *event)
+{
+#ifdef HAVE_EVENTFD
+	if (close(event->eventfd) == -1)
+		usbi_warn(NULL, "failed to close eventfd, errno=%d", errno);
+#else
+	if (close(event->pipefd[1]) == -1)
+		usbi_warn(NULL, "failed to close pipe write end, errno=%d", errno);
+	if (close(event->pipefd[0]) == -1)
+		usbi_warn(NULL, "failed to close pipe read end, errno=%d", errno);
+#endif
+}
+
+void usbi_signal_event(usbi_event_t *event)
+{
+	uint64_t dummy = 1;
+	ssize_t r;
+
+	r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
+	if (r != sizeof(dummy))
+		usbi_warn(NULL, "event write failed");
+}
+
+void usbi_clear_event(usbi_event_t *event)
+{
+	uint64_t dummy;
+	ssize_t r;
+
+	r = read(EVENT_READ_FD(event), &dummy, sizeof(dummy));
+	if (r != sizeof(dummy))
+		usbi_warn(NULL, "event read failed");
+}
+
+#ifdef HAVE_TIMERFD
+int usbi_create_timer(usbi_timer_t *timer)
+{
+	timer->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
+	if (timer->timerfd == -1) {
+		usbi_warn(NULL, "failed to create timerfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+void usbi_destroy_timer(usbi_timer_t *timer)
+{
+	if (close(timer->timerfd) == -1)
+		usbi_warn(NULL, "failed to close timerfd, errno=%d", errno);
+}
+
+int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
+{
+	const struct itimerspec it = { { 0, 0 }, { timeout->tv_sec, timeout->tv_nsec } };
+
+	if (timerfd_settime(timer->timerfd, TFD_TIMER_ABSTIME, &it, NULL) == -1) {
+		usbi_warn(NULL, "failed to arm timerfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+
+int usbi_disarm_timer(usbi_timer_t *timer)
+{
+	const struct itimerspec it = { { 0, 0 }, { 0, 0 } };
+
+	if (timerfd_settime(timer->timerfd, 0, &it, NULL) == -1) {
+		usbi_warn(NULL, "failed to disarm timerfd, errno=%d", errno);
+		return LIBUSB_ERROR_OTHER;
+	}
+
+	return 0;
+}
+#endif
+
+int usbi_alloc_event_data(struct libusb_context *ctx)
+{
+	struct usbi_event_source *ievent_source;
+	struct pollfd *fds;
+	size_t i = 0;
+
+	if (ctx->event_data) {
+		free(ctx->event_data);
+		ctx->event_data = NULL;
+	}
+
+	ctx->event_data_cnt = 0;
+	for_each_event_source(ctx, ievent_source)
+		ctx->event_data_cnt++;
+
+	fds = calloc(ctx->event_data_cnt, sizeof(*fds));
+	if (!fds)
+		return LIBUSB_ERROR_NO_MEM;
+
+	for_each_event_source(ctx, ievent_source) {
+		fds[i].fd = ievent_source->data.os_handle;
+		fds[i].events = ievent_source->data.poll_events;
+		i++;
+	}
+
+	ctx->event_data = fds;
+	return 0;
+}
+
+int usbi_wait_for_events(struct libusb_context *ctx,
+	struct usbi_reported_events *reported_events, int timeout_ms)
+{
+	struct pollfd *fds = ctx->event_data;
+	usbi_nfds_t nfds = (usbi_nfds_t)ctx->event_data_cnt;
+	int internal_fds, num_ready;
+
+	usbi_dbg(ctx, "poll() %u fds with timeout in %dms", (unsigned int)nfds, timeout_ms);
+	num_ready = poll(fds, nfds, timeout_ms);
+	usbi_dbg(ctx, "poll() returned %d", num_ready);
+	if (num_ready == 0) {
+		if (usbi_using_timer(ctx))
+			goto done;
+		return LIBUSB_ERROR_TIMEOUT;
+	} else if (num_ready == -1) {
+		if (errno == EINTR)
+			return LIBUSB_ERROR_INTERRUPTED;
+		usbi_err(ctx, "poll() failed, errno=%d", errno);
+		return LIBUSB_ERROR_IO;
+	}
+
+	/* fds[0] is always the internal signalling event */
+	if (fds[0].revents) {
+		reported_events->event_triggered = 1;
+		num_ready--;
+	} else {
+		reported_events->event_triggered = 0;
+	}
+
+#ifdef HAVE_OS_TIMER
+	/* on timer configurations, fds[1] is the timer */
+	if (usbi_using_timer(ctx) && fds[1].revents) {
+		reported_events->timer_triggered = 1;
+		num_ready--;
+	} else {
+		reported_events->timer_triggered = 0;
+	}
+#endif
+
+	if (!num_ready)
+		goto done;
+
+	/* the backend will never need to attempt to handle events on the
+	 * library's internal file descriptors, so we determine how many are
+	 * in use internally for this context and skip these when passing any
+	 * remaining pollfds to the backend. */
+	internal_fds = usbi_using_timer(ctx) ? 2 : 1;
+	fds += internal_fds;
+	nfds -= internal_fds;
+
+	usbi_mutex_lock(&ctx->event_data_lock);
+	if (ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
+		struct usbi_event_source *ievent_source;
+
+		for_each_removed_event_source(ctx, ievent_source) {
+			usbi_nfds_t n;
+
+			for (n = 0; n < nfds; n++) {
+				if (ievent_source->data.os_handle != fds[n].fd)
+					continue;
+				if (!fds[n].revents)
+					continue;
+				/* pollfd was removed between the creation of the fds array and
+				 * here. remove triggered revent as it is no longer relevant. */
+				usbi_dbg(ctx, "fd %d was removed, ignoring raised events", fds[n].fd);
+				fds[n].revents = 0;
+				num_ready--;
+				break;
+			}
+		}
+	}
+	usbi_mutex_unlock(&ctx->event_data_lock);
+
+	if (num_ready) {
+		assert(num_ready > 0);
+		reported_events->event_data = fds;
+		reported_events->event_data_count = (unsigned int)nfds;
+	}
+
+done:
+	reported_events->num_ready = num_ready;
+	return LIBUSB_SUCCESS;
+}

package/libusb/libusb/os/events_posix.h

@@ -0,0 +1,59 @@
+/*
+ * libusb event abstraction on POSIX platforms
+ *
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef LIBUSB_EVENTS_POSIX_H
+#define LIBUSB_EVENTS_POSIX_H
+
+#include <poll.h>
+
+typedef int usbi_os_handle_t;
+#define USBI_OS_HANDLE_FORMAT_STRING	"fd %d"
+
+#ifdef HAVE_EVENTFD
+typedef struct usbi_event {
+	int eventfd;
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->eventfd)
+#define USBI_EVENT_POLL_EVENTS	POLLIN
+#define USBI_INVALID_EVENT	{ -1 }
+#else
+typedef struct usbi_event {
+	int pipefd[2];
+} usbi_event_t;
+#define USBI_EVENT_OS_HANDLE(e)	((e)->pipefd[0])
+#define USBI_EVENT_POLL_EVENTS	POLLIN
+#define USBI_INVALID_EVENT	{ { -1, -1 } }
+#endif
+
+#ifdef HAVE_TIMERFD
+#define HAVE_OS_TIMER 1
+typedef struct usbi_timer {
+	int timerfd;
+} usbi_timer_t;
+#define USBI_TIMER_OS_HANDLE(t)	((t)->timerfd)
+#define USBI_TIMER_POLL_EVENTS	POLLIN
+
+static inline int usbi_timer_valid(usbi_timer_t *timer)
+{
+	return timer->timerfd >= 0;
+}
+#endif
+
+#endif