usb 2.16.0 → 2.18.0

package/libusb/libusb/os/darwin_usb.h

@@ -117,7 +117,7 @@ struct darwin_cached_device {
   UInt8                 first_config, active_config, port;
   int                   can_enumerate;
   int                   refcount;
-  bool                  in_reenumerate;
+  atomic_bool           in_reenumerate;
   int                   capture_count;
 };
 
@@ -125,17 +125,19 @@ struct darwin_device_priv {
   struct darwin_cached_device *dev;
 };
 
+struct darwin_interface {
+  usb_interface_t      interface;
+  uint8_t              num_endpoints;
+  CFRunLoopSourceRef   cfSource;
+  uint64_t             frames[256];
+  uint8_t              endpoint_addrs[USB_MAXENDPOINTS];
+};
+
 struct darwin_device_handle_priv {
   bool                 is_open;
   CFRunLoopSourceRef   cfSource;
 
-  struct darwin_interface {
-    usb_interface_t      interface;
-    uint8_t              num_endpoints;
-    CFRunLoopSourceRef   cfSource;
-    uint64_t             frames[256];
-    uint8_t              endpoint_addrs[USB_MAXENDPOINTS];
-  } interfaces[USB_MAXINTERFACES];
+  struct darwin_interface interfaces[USB_MAXINTERFACES];
 };
 
 struct darwin_transfer_priv {

package/libusb/libusb/os/emscripten_webusb.cpp

@@ -538,17 +538,36 @@ private:
 		auto configurations_len = dev->device_descriptor.bNumConfigurations;
 		configurations.reserve(configurations_len);
 		for (uint8_t j = 0; j < configurations_len; j++) {
-			// Note: requesting more than (platform-specific limit) bytes
-			// here will cause the transfer to fail, see
-			// https://crbug.com/1489414. Use the most common limit of 4096
-			// bytes for now.
-			constexpr uint16_t MAX_CTRL_BUFFER_LENGTH = 4096;
-			auto result = co_await_try(
-				requestDescriptor(LIBUSB_DT_CONFIG, j, MAX_CTRL_BUFFER_LENGTH));
-			if (auto error = getTransferStatus(result)) {
+			// Read descriptor header first to discover target length.
+			auto config_header_result = co_await_try(
+				requestDescriptor(LIBUSB_DT_CONFIG, j, LIBUSB_DT_CONFIG_SIZE));
+			if (auto error = getTransferStatus(config_header_result)) {
 				co_return error;
 			}
-			auto configVal = result["data"];
+			union usbi_config_desc_buf config_header = {};
+			copyFromDataView(config_header.buf, config_header_result["data"]);
+			if (config_header.desc.bDescriptorType != LIBUSB_DT_CONFIG ||
+				config_header.desc.bLength < LIBUSB_DT_CONFIG_SIZE) {
+				co_return LIBUSB_ERROR_IO;
+			}
+
+			auto config_total_length =
+				libusb_le16_to_cpu(config_header.desc.wTotalLength);
+			if (config_total_length < LIBUSB_DT_CONFIG_SIZE) {
+				co_return LIBUSB_ERROR_IO;
+			}
+
+			auto config_result = co_await_try(
+				requestDescriptor(LIBUSB_DT_CONFIG, j, config_total_length));
+			if (auto error = getTransferStatus(config_result)) {
+				co_return error;
+			}
+
+			auto configVal = config_result["data"];
+			if (configVal["byteLength"].as<size_t>() < config_total_length) {
+				co_return LIBUSB_ERROR_IO;
+			}
+
 			auto configLen = configVal["byteLength"].as<size_t>();
 			auto& config = configurations.emplace_back(
 				(usbi_configuration_descriptor*)::operator new(configLen));
@@ -586,12 +605,17 @@ unsigned long getDeviceSessionId(val& web_usb_device) {
 }
 
 val getDeviceList(libusb_context* ctx, discovered_devs** devs) {
+	// Check if browser supports USB
+	val navigator_usb = val::global("navigator")["usb"];
+	if (navigator_usb == val::undefined()) {
+		co_return (int) LIBUSB_ERROR_NOT_SUPPORTED;
+	}
 	// C++ equivalent of `await navigator.usb.getDevices()`. Note: at this point
 	// we must already have some devices exposed - caller must have called
 	// `await navigator.usb.requestDevice(...)` in response to user interaction
 	// before going to LibUSB. Otherwise this list will be empty.
 	auto web_usb_devices =
-		co_await_try(val::global("navigator")["usb"].call<val>("getDevices"));
+		co_await_try(navigator_usb.call<val>("getDevices"));
 	for (auto&& web_usb_device : web_usb_devices) {
 		auto session_id = getDeviceSessionId(web_usb_device);
 
@@ -618,6 +642,8 @@ val getDeviceList(libusb_context* ctx, discovered_devs** devs) {
 			// This can wrap around but it's the best approximation of a stable
 			// device address and port number we can provide.
 			dev->device_address = dev->port_number = (uint8_t)session_id;
+
+			usbi_connect_device(dev);
 		}
 		*devs = discovered_devs_append(*devs, dev);
 		libusb_unref_device(dev);
@@ -701,7 +727,7 @@ int em_get_config_descriptor_by_value(libusb_device* dev,
 }
 
 int em_set_configuration(libusb_device_handle* dev_handle, int config) {
-	return WebUsbDevicePtr(dev_handle)->awaitOnMain("setConfiguration", config);
+	return WebUsbDevicePtr(dev_handle)->awaitOnMain("selectConfiguration", config);
 }
 
 int em_claim_interface(libusb_device_handle* handle, uint8_t iface) {
@@ -844,7 +870,7 @@ int em_handle_transfer_completion(usbi_transfer* itransfer) {
 #pragma clang diagnostic ignored "-Wmissing-field-initializers"
 extern "C" const usbi_os_backend usbi_backend = {
 	.name = "Emscripten + WebUSB backend",
-	.caps = LIBUSB_CAP_HAS_CAPABILITY,
+	.caps = 0,
 	.get_device_list = em_get_device_list,
 	.open = em_open,
 	.close = em_close,

package/libusb/libusb/os/events_posix.c

@@ -256,11 +256,11 @@ int usbi_wait_for_events(struct libusb_context *ctx,
 
 	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.
+	/* 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.
+	/* 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);

package/libusb/libusb/os/haiku_usb_raw.cpp

@@ -186,6 +186,7 @@ const struct usbi_os_backend usbi_backend = {
 	/*.exit =*/ haiku_exit,
 	/*.set_option =*/ NULL,
 	/*.get_device_list =*/ NULL,
+	/*.get_device_string =*/ NULL,
 	/*.hotplug_poll =*/ NULL,
 	/*.wrap_sys_device =*/ NULL,
 	/*.open =*/ haiku_open,
@@ -214,6 +215,9 @@ const struct usbi_os_backend usbi_backend = {
 	/*.kernel_driver_active =*/ NULL,
 	/*.detach_kernel_driver =*/ NULL,
 	/*.attach_kernel_driver =*/ NULL,
+	/*.endpoint_supports_raw_io =*/ NULL,
+	/*.endpoint_set_raw_io =*/ NULL,
+	/*.get_max_raw_io_transfer_size =*/ NULL,
 
 	/*.destroy_device =*/ NULL,
 

package/libusb/libusb/os/linux_usbfs.c

@@ -98,6 +98,8 @@ static int init_count = 0;
 /* Serialize scan-devices, event-thread, and poll */
 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
 
+static int open_sysfs_attr(struct libusb_context *ctx,
+	const char *sysfs_dir, const char *attr);
 static int linux_scan_devices(struct libusb_context *ctx);
 static int detach_kernel_driver_and_claim(struct libusb_device_handle *, uint8_t);
 
@@ -182,7 +184,7 @@ static int dev_has_config0(struct libusb_device *dev)
 	return 0;
 }
 
-static int get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
+static int get_usbfs_fd(struct libusb_device *dev, int access_mode, int silent)
 {
 	struct libusb_context *ctx = DEVICE_CTX(dev);
 	char path[24];
@@ -195,28 +197,34 @@ static int get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
 		snprintf(path, sizeof(path), USB_DEVTMPFS_PATH "/%03u/%03u",
 			dev->bus_number, dev->device_address);
 
-	fd = open(path, mode | O_CLOEXEC);
+	fd = open(path, access_mode | O_CLOEXEC);
 	if (fd != -1)
 		return fd; /* Success */
 
+	/* TODO: fix race between netlink and usbfs https://github.com/libusb/libusb/issues/1691 */
 	if (errno == ENOENT) {
 		const long delay_ms = 10L;
 		const struct timespec delay_ts = { 0L, delay_ms * 1000L * 1000L };
+		uint8_t retry = 3;
 
-		if (!silent)
-			usbi_err(ctx, "File doesn't exist, wait %ld ms and try again", delay_ms);
+		while (retry-- > 0) {
+			if (!silent)
+				usbi_err(ctx, "File doesn't exist, wait %ld ms and try again", delay_ms);
 
-		/* Wait 10ms for USB device path creation.*/
-		nanosleep(&delay_ts, NULL);
+			/* Wait 10ms for USB device path creation.*/
+			nanosleep(&delay_ts, NULL);
 
-		fd = open(path, mode | O_CLOEXEC);
-		if (fd != -1)
-			return fd; /* Success */
+			fd = open(path, access_mode | O_CLOEXEC);
+			if (fd != -1)
+				return fd; /* Success */
+			if (errno != ENOENT)
+				break;
+		}
 	}
 
 	if (!silent) {
 		usbi_err(ctx, "libusb couldn't open USB device %s, errno=%d", path, errno);
-		if (errno == EACCES && mode == O_RDWR)
+		if (errno == EACCES && access_mode == O_RDWR)
 			usbi_err(ctx, "libusb requires write access to USB device nodes");
 	}
 
@@ -293,16 +301,7 @@ static const char *find_usbfs_path(void)
 		}
 	}
 
-/* On udev based systems without any usb-devices /dev/bus/usb will not
- * exist. So if we've not found anything and we're using udev for hotplug
- * simply assume /dev/bus/usb rather then making libusb_init fail.
- * Make the same assumption for Android where SELinux policies might block us
- * from reading /dev on newer devices. */
-#if defined(HAVE_LIBUDEV) || defined(__ANDROID__)
-	return USB_DEVTMPFS_PATH;
-#else
 	return NULL;
-#endif
 }
 
 static int get_kernel_version(struct libusb_context *ctx,
@@ -370,12 +369,16 @@ static int op_init(struct libusb_context *ctx)
 
 	usbfs_path = find_usbfs_path();
 	if (!usbfs_path) {
-		usbi_err(ctx, "could not find usbfs");
-		return LIBUSB_ERROR_OTHER;
+		/* On udev based systems without any usb devices /dev/bus/usb will not
+		* exist. On android and other systems SELinux policies might block us
+		* from reading /dev. Nonetheless it's the default for most modern linux
+		systems including those using udev alternatives such as busybox's mdev. */
+		usbfs_path = USB_DEVTMPFS_PATH;
+		usbi_dbg(ctx, "could not find usbfs, defaulting to %s", usbfs_path);
+	} else {
+		usbi_dbg(ctx, "found usbfs at %s", usbfs_path);
 	}
 
-	usbi_dbg(ctx, "found usbfs at %s", usbfs_path);
-
 	if (!max_iso_packet_len) {
 		if (kernel_version_ge(&kversion, 5, 2, 0))
 			max_iso_packet_len = 98304;
@@ -452,6 +455,46 @@ static int op_set_option(struct libusb_context *ctx, enum libusb_option option,
 	return LIBUSB_ERROR_NOT_SUPPORTED;
 }
 
+static int op_get_device_string(struct libusb_device *dev, 
+		enum libusb_device_string_type string_type, char *buffer, int length)
+{
+	ssize_t r;
+	int fd;
+	struct linux_device_priv *priv = usbi_get_device_priv(dev);
+	struct libusb_context* ctx = DEVICE_CTX(dev);
+	const char * attr;
+
+	switch (string_type) {
+		case LIBUSB_DEVICE_STRING_MANUFACTURER: attr = "manufacturer"; break;
+		case LIBUSB_DEVICE_STRING_PRODUCT: attr = "product"; break;
+		case LIBUSB_DEVICE_STRING_SERIAL_NUMBER: attr = "serial"; break;
+		case LIBUSB_DEVICE_STRING_COUNT:
+			/* intentional fall-through, avoid -Wswitch-enum */
+		default:
+			return LIBUSB_ERROR_INVALID_PARAM;
+	}
+	fd = open_sysfs_attr(ctx, priv->sysfs_dir, attr);
+	if (fd < 0)
+		return LIBUSB_ERROR_IO;
+
+	r = read(fd, buffer, length - 1);  // leave space for null terminator
+	if (r < 0) {
+		r = errno;
+		close(fd);
+		if (r == ENODEV)
+			return LIBUSB_ERROR_NO_DEVICE;
+		usbi_err(ctx, "attribute %s read failed, errno=%zd", attr, r);
+		return LIBUSB_ERROR_IO;
+	}
+	close(fd);
+	buffer[r] = 0;  // add null terminator
+	while (r && ((buffer[r] == 0) || (buffer[r] == '\n'))) {
+		buffer[r--] = 0;
+	}
+	++r;
+	return r;
+}
+
 static int linux_scan_devices(struct libusb_context *ctx)
 {
 	int ret;
@@ -541,7 +584,7 @@ static int read_sysfs_attr(struct libusb_context *ctx,
 
 	errno = 0;
 	value = strtol(buf, &endptr, 10);
-	if (value < 0 || value > (long)max_value || errno) {
+	if (buf == endptr || value < 0 || value > (long)max_value || errno) {
 		usbi_err(ctx, "attribute %s contains an invalid value: '%s'", attr, buf);
 		return LIBUSB_ERROR_INVALID_PARAM;
 	} else if (*endptr != '\0') {
@@ -933,6 +976,7 @@ static int initialize_device(struct libusb_device *dev, uint8_t busnum,
 			case   480: dev->speed = LIBUSB_SPEED_HIGH; break;
 			case  5000: dev->speed = LIBUSB_SPEED_SUPER; break;
 			case 10000: dev->speed = LIBUSB_SPEED_SUPER_PLUS; break;
+			case 20000: dev->speed = LIBUSB_SPEED_SUPER_PLUS_X2; break;
 			default:
 				usbi_warn(ctx, "unknown device speed: %d Mbps", speed);
 			}
@@ -1032,7 +1076,7 @@ static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_di
 {
 	struct libusb_context *ctx = DEVICE_CTX(dev);
 	struct libusb_device *it;
-	char *parent_sysfs_dir, *tmp;
+	char *parent_sysfs_dir, *tmp, *end;
 	int ret, add_parent = 1;
 
 	/* XXX -- can we figure out the topology when using usbfs? */
@@ -1047,7 +1091,16 @@ static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_di
 
 	if ((tmp = strrchr(parent_sysfs_dir, '.')) ||
 	    (tmp = strrchr(parent_sysfs_dir, '-'))) {
-	        dev->port_number = atoi(tmp + 1);
+		const char *start = tmp + 1;
+		long port_number = strtol(start, &end, 10);
+		if (port_number < 0 || port_number > INT_MAX || start == end || '\0' != *end) {
+			usbi_warn(ctx, "Can not parse sysfs_dir: %s, unexpected parent info",
+				parent_sysfs_dir);
+			free(parent_sysfs_dir);
+			return LIBUSB_ERROR_OTHER;
+		} else {
+			dev->port_number = (int)port_number;
+		}
 		*tmp = '\0';
 	} else {
 		usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
@@ -1244,6 +1297,10 @@ static int usbfs_get_device_list(struct libusb_context *ctx)
 		buses = opendir(USB_DEVTMPFS_PATH);
 
 	if (!buses) {
+		if (!usbdev_names && errno == ENOENT) {
+			/* The path does not exist if there are no devices plugged in */
+			return LIBUSB_SUCCESS;
+		}
 		usbi_err(ctx, "opendir buses failed, errno=%d", errno);
 		return LIBUSB_ERROR_IO;
 	}
@@ -1321,10 +1378,10 @@ static int linux_default_scan_devices(struct libusb_context *ctx)
 	 * any autosuspended USB devices. however, sysfs is not available
 	 * everywhere, so we need a usbfs fallback too.
 	 */
-	if (sysfs_available)
-		return sysfs_get_device_list(ctx);
-	else
-		return usbfs_get_device_list(ctx);
+	if (sysfs_available && sysfs_get_device_list(ctx) == LIBUSB_SUCCESS)
+		return LIBUSB_SUCCESS;
+
+    return usbfs_get_device_list(ctx);
 }
 #endif
 
@@ -1627,8 +1684,9 @@ out:
 	return ret;
 }
 
-static int do_streams_ioctl(struct libusb_device_handle *handle, long req,
-	uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
+static int do_streams_ioctl(struct libusb_device_handle *handle,
+	unsigned long req, uint32_t num_streams, unsigned char *endpoints,
+	int num_endpoints)
 {
 	struct linux_device_handle_priv *hpriv = usbi_get_device_handle_priv(handle);
 	int r, fd = hpriv->fd;
@@ -2749,7 +2807,7 @@ static int op_handle_events(struct libusb_context *ctx,
 				} while (r == 0);
 			}
 
-			usbi_handle_disconnect(handle);
+			usbi_handle_disconnect(ctx, handle);
 			continue;
 		}
 
@@ -2776,6 +2834,7 @@ const struct usbi_os_backend usbi_backend = {
 	.init = op_init,
 	.exit = op_exit,
 	.set_option = op_set_option,
+	.get_device_string = op_get_device_string,
 	.hotplug_poll = op_hotplug_poll,
 	.get_active_config_descriptor = op_get_active_config_descriptor,
 	.get_config_descriptor = op_get_config_descriptor,

package/libusb/libusb/os/linux_usbfs.h

@@ -174,7 +174,17 @@ static inline int linux_start_event_monitor(void)
 {
 #if defined(HAVE_LIBUDEV)
 	return linux_udev_start_event_monitor();
-#elif !defined(__ANDROID__)
+/*
+* __ANDROID__: preprocessor macro defined automatically by GCC for all Android
+*              targets (i.e. both Android native applications, and Android OS-level
+*              services)
+*
+* ANDROID_OS: compilation flag that should be set for using libusb from programs
+*             running on Android at OS level (e.g. Android platform services).
+*             The programs using libusb built with the ANDROID_OS flag must have
+*             permission to access netlink sockets.
+*/
+#elif !defined(__ANDROID__) || defined(ANDROID_OS)
 	return linux_netlink_start_event_monitor();
 #else
 	return LIBUSB_SUCCESS;
@@ -185,7 +195,7 @@ static inline void linux_stop_event_monitor(void)
 {
 #if defined(HAVE_LIBUDEV)
 	linux_udev_stop_event_monitor();
-#elif !defined(__ANDROID__)
+#elif !defined(__ANDROID__) || defined(ANDROID_OS)
 	linux_netlink_stop_event_monitor();
 #endif
 }
@@ -194,7 +204,7 @@ static inline void linux_hotplug_poll(void)
 {
 #if defined(HAVE_LIBUDEV)
 	linux_udev_hotplug_poll();
-#elif !defined(__ANDROID__)
+#elif !defined(__ANDROID__) || defined(ANDROID_OS)
 	linux_netlink_hotplug_poll();
 #endif
 }

package/libusb/libusb/os/netbsd_usb.c

@@ -171,6 +171,8 @@ netbsd_get_device_list(struct libusb_context * ctx,
 
 			if ((err = usbi_sanitize_device(dev)))
 				goto error;
+
+			usbi_connect_device(dev);
 		}
 		close(fd);
 
@@ -444,6 +446,8 @@ netbsd_handle_transfer_completion(struct usbi_transfer *itransfer)
 int
 _errno_to_libusb(int err)
 {
+	usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
+
 	switch (err) {
 	case EIO:
 		return LIBUSB_ERROR_IO;
@@ -456,11 +460,9 @@ _errno_to_libusb(int err)
 	case EWOULDBLOCK:
 	case ETIMEDOUT:
 		return LIBUSB_ERROR_TIMEOUT;
+	default:
+		return LIBUSB_ERROR_OTHER;
 	}
-
-	usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
-
-	return LIBUSB_ERROR_OTHER;
 }
 
 int

package/libusb/libusb/os/openbsd_usb.c

@@ -200,6 +200,8 @@ obsd_get_device_list(struct libusb_context * ctx,
 					libusb_unref_device(dev);
 					continue;
 				}
+
+				usbi_connect_device(dev);
 			}
 
 			ddd = discovered_devs_append(*discdevs, dev);
@@ -495,9 +497,9 @@ _errno_to_libusb(int err)
 		return LIBUSB_ERROR_NO_MEM;
 	case ETIMEDOUT:
 		return LIBUSB_ERROR_TIMEOUT;
+	default:
+		return LIBUSB_ERROR_OTHER;
 	}
-
-	return LIBUSB_ERROR_OTHER;
 }
 
 int

package/libusb/libusb/os/sunos_usb.c

@@ -86,7 +86,7 @@ static int sunos_get_link(di_devlink_t devlink, void *arg)
 	const char *p;
 	const char *q;
 
-	if (larg->path) {
+	if (link_arg->path) {
 		char *content = (char *)di_devlink_content(devlink);
 		char *start = strstr(content, "/devices/");
 		start += strlen("/devices");
@@ -94,8 +94,8 @@ static int sunos_get_link(di_devlink_t devlink, void *arg)
 
 		/* line content must have minor node */
 		if (start == NULL ||
-		    strncmp(start, larg->path, larg->len) != 0 ||
-		    start[larg->len] != ':')
+		    strncmp(start, link_arg->path, link_arg->len) != 0 ||
+		    start[link_arg->len] != ':')
 			return (DI_WALK_CONTINUE);
 	}
 
@@ -103,7 +103,7 @@ static int sunos_get_link(di_devlink_t devlink, void *arg)
 	q = strrchr(p, '/');
 	usbi_dbg(NULL, "%s", q);
 
-	*(larg->linkpp) = strndup(p, strlen(p) - strlen(q));
+	*(link_arg->linkpp) = strndup(p, strlen(p) - strlen(q));
 
 	return (DI_WALK_TERMINATE);
 }
@@ -171,7 +171,7 @@ sunos_usb_ioctl(struct libusb_device *dev, int cmd)
 
 	nvlist_alloc(&nvlist, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
 	nvlist_add_int32(nvlist, "port", dev->port_number);
-	//find the hub path
+	/* find the hub path */
 	snprintf(path_arg, sizeof(path_arg), "/devices%s:hubd", hubpath);
 	usbi_dbg(DEVICE_CTX(dev), "ioctl hub path: %s", path_arg);
 
@@ -627,6 +627,8 @@ sunos_add_devices(di_devlink_t link, void *arg)
 				usbi_dbg(NULL, "sanitize failed: ");
 				return (DI_WALK_TERMINATE);
 			}
+
+			usbi_connect_device(dev);
 		} else {
 			devpriv = usbi_get_device_priv(dev);
 			usbi_dbg(NULL, "Dev %s exists", devpriv->ugenpath);

package/libusb/libusb/os/threads_posix.c

@@ -22,6 +22,7 @@
 #include "libusbi.h"
 
 #include <errno.h>
+#include <limits.h>
 #if defined(__ANDROID__)
 # include <unistd.h>
 #elif defined(__HAIKU__)
@@ -37,7 +38,7 @@
 # include <sys/lwp.h>
 #endif
 
-void usbi_cond_init(pthread_cond_t *cond)
+void usbi_cond_init(usbi_cond_t *cond)
 {
 #ifdef HAVE_PTHREAD_CONDATTR_SETCLOCK
 	pthread_condattr_t condattr;
@@ -51,8 +52,8 @@ void usbi_cond_init(pthread_cond_t *cond)
 #endif
 }
 
-int usbi_cond_timedwait(pthread_cond_t *cond,
-	pthread_mutex_t *mutex, const struct timeval *tv)
+int usbi_cond_timedwait(usbi_cond_t *cond,
+	usbi_mutex_t *mutex, const struct timeval *tv)
 {
 	struct timespec timeout;
 	int r;
@@ -79,47 +80,47 @@ int usbi_cond_timedwait(pthread_cond_t *cond,
 		return LIBUSB_ERROR_OTHER;
 }
 
-unsigned int usbi_get_tid(void)
+unsigned long usbi_get_tid(void)
 {
-	static _Thread_local unsigned int tl_tid;
-	int tid;
+	static _Thread_local unsigned long tl_tid;
+	unsigned long tid;
 
 	if (tl_tid)
 		return tl_tid;
 
 #if defined(__ANDROID__)
-	tid = gettid();
+	tid = (unsigned long)gettid();
 #elif defined(__APPLE__)
 #ifdef HAVE_PTHREAD_THREADID_NP
 	uint64_t thread_id;
 
 	if (pthread_threadid_np(NULL, &thread_id) == 0)
-		tid = (int)thread_id;
+		tid = (unsigned long)thread_id;
 	else
-		tid = -1;
+		tid = ULONG_MAX;
 #else
-	tid = (int)pthread_mach_thread_np(pthread_self());
+	tid = (unsigned long)pthread_mach_thread_np(pthread_self());
 #endif
 #elif defined(__HAIKU__)
-	tid = get_pthread_thread_id(pthread_self());
+	tid = (unsigned long)get_pthread_thread_id(pthread_self());
 #elif defined(__linux__)
-	tid = (int)syscall(SYS_gettid);
+	tid = (unsigned long)syscall(SYS_gettid);
 #elif defined(__NetBSD__)
-	tid = _lwp_self();
+	tid = (unsigned long)_lwp_self();
 #elif defined(__OpenBSD__)
-	tid = getthrid();
+	tid = (unsigned long)getthrid();
 #elif defined(__sun__)
-	tid = _lwp_self();
+	tid = (unsigned long)_lwp_self();
 #else
-	tid = -1;
+	tid = ULONG_MAX;
 #endif
 
-	if (tid == -1) {
+	if (tid == ULONG_MAX) {
 		/* If we don't have a thread ID, at least return a unique
 		 * value that can be used to distinguish individual
 		 * threads. */
-		tid = (int)(intptr_t)pthread_self();
+		tid = (unsigned long)(uintptr_t)pthread_self();
 	}
 
-	return tl_tid = (unsigned int)tid;
+	return tl_tid = tid;
 }

package/libusb/libusb/os/threads_posix.h

@@ -51,21 +51,27 @@ static inline void usbi_mutex_unlock(usbi_mutex_t *mutex)
 }
 static inline int usbi_mutex_trylock(usbi_mutex_t *mutex)
 {
-	return pthread_mutex_trylock(mutex) == 0;
+	int mutexIsLocked = pthread_mutex_trylock(mutex) == 0;
+	return mutexIsLocked;
 }
 static inline void usbi_mutex_destroy(usbi_mutex_t *mutex)
 {
 	PTHREAD_CHECK(pthread_mutex_destroy(mutex));
 }
 
+#define USBI_COND_INITIALIZER	PTHREAD_COND_INITIALIZER
 typedef pthread_cond_t usbi_cond_t;
-void usbi_cond_init(pthread_cond_t *cond);
+void usbi_cond_init(usbi_cond_t *cond);
 static inline void usbi_cond_wait(usbi_cond_t *cond, usbi_mutex_t *mutex)
 {
 	PTHREAD_CHECK(pthread_cond_wait(cond, mutex));
 }
 int usbi_cond_timedwait(usbi_cond_t *cond,
 	usbi_mutex_t *mutex, const struct timeval *tv);
+static inline void usbi_cond_signal(usbi_cond_t *cond)
+{
+	PTHREAD_CHECK(pthread_cond_signal(cond));
+}
 static inline void usbi_cond_broadcast(usbi_cond_t *cond)
 {
 	PTHREAD_CHECK(pthread_cond_broadcast(cond));
@@ -93,6 +99,6 @@ static inline void usbi_tls_key_delete(usbi_tls_key_t key)
 	PTHREAD_CHECK(pthread_key_delete(key));
 }
 
-unsigned int usbi_get_tid(void);
+unsigned long usbi_get_tid(void);
 
 #endif /* LIBUSB_THREADS_POSIX_H */