usb 1.7.2 → 1.8.0-libusb.2

package/libusb/libusb/os/linux_netlink.c

@@ -4,6 +4,7 @@
  * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
  * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
  * Copyright (c) 2013 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright (c) 2016 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
@@ -20,40 +21,37 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "config.h"
-#include "libusb.h"
-#include "libusbi.h"
-#include "linux_usbfs.h"
+#include <config.h>
 
-#include <ctype.h>
-#include <dirent.h>
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include <sys/types.h>
 
 #ifdef HAVE_ASM_TYPES_H
 #include <asm/types.h>
 #endif
 
-#ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>
-#endif
+#include <linux/netlink.h>
 
-#include <arpa/inet.h>
+#include "libusbi.h"
+#include "linux_usbfs.h"
 
-#ifdef HAVE_LINUX_NETLINK_H
-#include <linux/netlink.h>
-#endif
+#define NL_GROUP_KERNEL 1
 
-#ifdef HAVE_LINUX_FILTER_H
-#include <linux/filter.h>
+#ifndef SOCK_CLOEXEC
+#define SOCK_CLOEXEC	0
 #endif
 
-#define KERNEL 1
+#ifndef SOCK_NONBLOCK
+#define SOCK_NONBLOCK	0
+#endif
 
 static int linux_netlink_socket = -1;
 static int netlink_control_pipe[2] = { -1, -1 };
@@ -61,30 +59,38 @@ static pthread_t libusb_linux_event_thread;
 
 static void *linux_netlink_event_thread_main(void *arg);
 
-struct sockaddr_nl snl = { .nl_family=AF_NETLINK, .nl_groups=KERNEL };
-
-static int set_fd_cloexec_nb (int fd)
+static int set_fd_cloexec_nb(int fd, int socktype)
 {
 	int flags;
 
 #if defined(FD_CLOEXEC)
-	flags = fcntl (linux_netlink_socket, F_GETFD);
-	if (0 > flags) {
-		return -1;
-	}
+	/* Make sure the netlink socket file descriptor is marked as CLOEXEC */
+	if (!(socktype & SOCK_CLOEXEC)) {
+		flags = fcntl(fd, F_GETFD);
+		if (flags == -1) {
+			usbi_err(NULL, "failed to get netlink fd flags (%d)", errno);
+			return -1;
+		}
 
-	if (!(flags & FD_CLOEXEC)) {
-		fcntl (linux_netlink_socket, F_SETFD, flags | FD_CLOEXEC);
+		if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
+			usbi_err(NULL, "failed to set netlink fd flags (%d)", errno);
+			return -1;
+		}
 	}
 #endif
 
-	flags = fcntl (linux_netlink_socket, F_GETFL);
-	if (0 > flags) {
-		return -1;
-	}
+	/* Make sure the netlink socket is non-blocking */
+	if (!(socktype & SOCK_NONBLOCK)) {
+		flags = fcntl(fd, F_GETFL);
+		if (flags == -1) {
+			usbi_err(NULL, "failed to get netlink fd status flags (%d)", errno);
+			return -1;
+		}
 
-	if (!(flags & O_NONBLOCK)) {
-		fcntl (linux_netlink_socket, F_SETFL, flags | O_NONBLOCK);
+		if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+			usbi_err(NULL, "failed to set netlink fd status flags (%d)", errno);
+			return -1;
+		}
 	}
 
 	return 0;
@@ -92,77 +98,78 @@ static int set_fd_cloexec_nb (int fd)
 
 int linux_netlink_start_event_monitor(void)
 {
-	int socktype = SOCK_RAW;
+	struct sockaddr_nl sa_nl = { .nl_family = AF_NETLINK, .nl_groups = NL_GROUP_KERNEL };
+	int socktype = SOCK_RAW | SOCK_NONBLOCK | SOCK_CLOEXEC;
+	int opt = 1;
 	int ret;
 
-	snl.nl_groups = KERNEL;
-
-#if defined(SOCK_CLOEXEC)
-	socktype |= SOCK_CLOEXEC;
-#endif
-#if defined(SOCK_NONBLOCK)
-	socktype |= SOCK_NONBLOCK;
-#endif
-
 	linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
-	if (-1 == linux_netlink_socket && EINVAL == errno) {
-		linux_netlink_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
+	if (linux_netlink_socket == -1 && errno == EINVAL) {
+		usbi_dbg("failed to create netlink socket of type %d, attempting SOCK_RAW", socktype);
+		socktype = SOCK_RAW;
+		linux_netlink_socket = socket(PF_NETLINK, socktype, NETLINK_KOBJECT_UEVENT);
 	}
 
-	if (-1 == linux_netlink_socket) {
-		return LIBUSB_ERROR_OTHER;
+	if (linux_netlink_socket == -1) {
+		usbi_err(NULL, "failed to create netlink socket (%d)", errno);
+		goto err;
 	}
 
-	ret = set_fd_cloexec_nb (linux_netlink_socket);
-	if (0 != ret) {
-		close (linux_netlink_socket);
-		linux_netlink_socket = -1;
-		return LIBUSB_ERROR_OTHER;
-	}
+	ret = set_fd_cloexec_nb(linux_netlink_socket, socktype);
+	if (ret == -1)
+		goto err_close_socket;
 
-	ret = bind(linux_netlink_socket, (struct sockaddr *) &snl, sizeof(snl));
-	if (0 != ret) {
-	        close(linux_netlink_socket);
-		return LIBUSB_ERROR_OTHER;
+	ret = bind(linux_netlink_socket, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+	if (ret == -1) {
+		usbi_err(NULL, "failed to bind netlink socket (%d)", errno);
+		goto err_close_socket;
 	}
 
-	/* TODO -- add authentication */
-	/* setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)); */
+	ret = setsockopt(linux_netlink_socket, SOL_SOCKET, SO_PASSCRED, &opt, sizeof(opt));
+	if (ret == -1) {
+		usbi_err(NULL, "failed to set netlink socket SO_PASSCRED option (%d)", errno);
+		goto err_close_socket;
+	}
 
 	ret = usbi_pipe(netlink_control_pipe);
 	if (ret) {
-		usbi_err(NULL, "could not create netlink control pipe");
-	        close(linux_netlink_socket);
-		return LIBUSB_ERROR_OTHER;
+		usbi_err(NULL, "failed to create netlink control pipe");
+		goto err_close_socket;
 	}
 
 	ret = pthread_create(&libusb_linux_event_thread, NULL, linux_netlink_event_thread_main, NULL);
-	if (0 != ret) {
-        	close(netlink_control_pipe[0]);
-        	close(netlink_control_pipe[1]);
-	        close(linux_netlink_socket);
-		return LIBUSB_ERROR_OTHER;
+	if (ret != 0) {
+		usbi_err(NULL, "failed to create netlink event thread (%d)", ret);
+		goto err_close_pipe;
 	}
 
 	return LIBUSB_SUCCESS;
+
+err_close_pipe:
+	close(netlink_control_pipe[0]);
+	close(netlink_control_pipe[1]);
+	netlink_control_pipe[0] = -1;
+	netlink_control_pipe[1] = -1;
+err_close_socket:
+	close(linux_netlink_socket);
+	linux_netlink_socket = -1;
+err:
+	return LIBUSB_ERROR_OTHER;
 }
 
 int linux_netlink_stop_event_monitor(void)
 {
-	int r;
 	char dummy = 1;
+	ssize_t r;
 
-	if (-1 == linux_netlink_socket) {
-		/* already closed. nothing to do */
-		return LIBUSB_SUCCESS;
-	}
+	assert(linux_netlink_socket != -1);
 
 	/* Write some dummy data to the control pipe and
 	 * wait for the thread to exit */
-	r = usbi_write(netlink_control_pipe[1], &dummy, sizeof(dummy));
-	if (r <= 0) {
+	r = write(netlink_control_pipe[1], &dummy, sizeof(dummy));
+	if (r <= 0)
 		usbi_warn(NULL, "netlink control pipe signal failed");
-	}
+
 	pthread_join(libusb_linux_event_thread, NULL);
 
 	close(linux_netlink_socket);
@@ -177,26 +184,25 @@ int linux_netlink_stop_event_monitor(void)
 	return LIBUSB_SUCCESS;
 }
 
-static const char *netlink_message_parse (const char *buffer, size_t len, const char *key)
+static const char *netlink_message_parse(const char *buffer, size_t len, const char *key)
 {
+	const char *end = buffer + len;
 	size_t keylen = strlen(key);
-	size_t offset;
 
-	for (offset = 0 ; offset < len && '\0' != buffer[offset] ; offset += strlen(buffer + offset) + 1) {
-		if (0 == strncmp(buffer + offset, key, keylen) &&
-		    '=' == buffer[offset + keylen]) {
-			return buffer + offset + keylen + 1;
-		}
+	while (buffer < end && *buffer) {
+		if (strncmp(buffer, key, keylen) == 0 && buffer[keylen] == '=')
+			return buffer + keylen + 1;
+		buffer += strlen(buffer) + 1;
 	}
 
 	return NULL;
 }
 
 /* parse parts of netlink message common to both libudev and the kernel */
-static int linux_netlink_parse(char *buffer, size_t len, int *detached, const char **sys_name,
-			       uint8_t *busnum, uint8_t *devaddr) {
-	const char *tmp;
-	int i;
+static int linux_netlink_parse(const char *buffer, size_t len, int *detached,
+	const char **sys_name, uint8_t *busnum, uint8_t *devaddr)
+{
+	const char *tmp, *slash;
 
 	errno = 0;
 
@@ -205,81 +211,82 @@ static int linux_netlink_parse(char *buffer, size_t len, int *detached, const ch
 	*busnum   = 0;
 	*devaddr  = 0;
 
-	tmp = netlink_message_parse((const char *) buffer, len, "ACTION");
-	if (tmp == NULL)
+	tmp = netlink_message_parse(buffer, len, "ACTION");
+	if (!tmp) {
 		return -1;
-	if (0 == strcmp(tmp, "remove")) {
+	} else if (strcmp(tmp, "remove") == 0) {
 		*detached = 1;
-	} else if (0 != strcmp(tmp, "add")) {
+	} else if (strcmp(tmp, "add") != 0) {
 		usbi_dbg("unknown device action %s", tmp);
 		return -1;
 	}
 
 	/* check that this is a usb message */
 	tmp = netlink_message_parse(buffer, len, "SUBSYSTEM");
-	if (NULL == tmp || 0 != strcmp(tmp, "usb")) {
+	if (!tmp || strcmp(tmp, "usb") != 0) {
+		/* not usb. ignore */
+		return -1;
+	}
+
+	/* check that this is an actual usb device */
+	tmp = netlink_message_parse(buffer, len, "DEVTYPE");
+	if (!tmp || strcmp(tmp, "usb_device") != 0) {
 		/* not usb. ignore */
 		return -1;
 	}
 
 	tmp = netlink_message_parse(buffer, len, "BUSNUM");
-	if (NULL == tmp) {
+	if (tmp) {
+		*busnum = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+
+		tmp = netlink_message_parse(buffer, len, "DEVNUM");
+		if (NULL == tmp)
+			return -1;
+
+		*devaddr = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
+		if (errno) {
+			errno = 0;
+			return -1;
+		}
+	} else {
 		/* no bus number. try "DEVICE" */
 		tmp = netlink_message_parse(buffer, len, "DEVICE");
-		if (NULL == tmp) {
+		if (!tmp) {
 			/* not usb. ignore */
 			return -1;
 		}
-		
+
 		/* Parse a device path such as /dev/bus/usb/003/004 */
-		char *pLastSlash = (char*)strrchr(tmp,'/');
-		if(NULL == pLastSlash) {
+		slash = strrchr(tmp, '/');
+		if (!slash)
 			return -1;
-		}
 
-		*devaddr = strtoul(pLastSlash + 1, NULL, 10);
+		*busnum = (uint8_t)(strtoul(slash - 3, NULL, 10) & 0xff);
 		if (errno) {
 			errno = 0;
 			return -1;
 		}
-		
-		*busnum = strtoul(pLastSlash - 3, NULL, 10);
+
+		*devaddr = (uint8_t)(strtoul(slash + 1, NULL, 10) & 0xff);
 		if (errno) {
 			errno = 0;
 			return -1;
 		}
-		
-		return 0;
-	}
-
-	*busnum = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
-	if (errno) {
-		errno = 0;
-		return -1;
-	}
-
-	tmp = netlink_message_parse(buffer, len, "DEVNUM");
-	if (NULL == tmp) {
-		return -1;
-	}
 
-	*devaddr = (uint8_t)(strtoul(tmp, NULL, 10) & 0xff);
-	if (errno) {
-		errno = 0;
-		return -1;
+		return 0;
 	}
 
 	tmp = netlink_message_parse(buffer, len, "DEVPATH");
-	if (NULL == tmp) {
+	if (!tmp)
 		return -1;
-	}
 
-	for (i = strlen(tmp) - 1 ; i ; --i) {
-		if ('/' ==tmp[i]) {
-			*sys_name = tmp + i + 1;
-			break;
-		}
-	}
+	slash = strrchr(tmp, '/');
+	if (slash)
+		*sys_name = slash + 1;
 
 	/* found a usb device */
 	return 0;
@@ -287,28 +294,54 @@ static int linux_netlink_parse(char *buffer, size_t len, int *detached, const ch
 
 static int linux_netlink_read_message(void)
 {
-	unsigned char buffer[1024];
-	struct iovec iov = {.iov_base = buffer, .iov_len = sizeof(buffer)};
-	struct msghdr meh = { .msg_iov=&iov, .msg_iovlen=1,
-			     .msg_name=&snl, .msg_namelen=sizeof(snl) };
+	char cred_buffer[CMSG_SPACE(sizeof(struct ucred))];
+	char msg_buffer[2048];
 	const char *sys_name = NULL;
 	uint8_t busnum, devaddr;
 	int detached, r;
-	size_t len;
+	ssize_t len;
+	struct cmsghdr *cmsg;
+	struct ucred *cred;
+	struct sockaddr_nl sa_nl;
+	struct iovec iov = { .iov_base = msg_buffer, .iov_len = sizeof(msg_buffer) };
+	struct msghdr msg = {
+		.msg_iov = &iov, .msg_iovlen = 1,
+		.msg_control = cred_buffer, .msg_controllen = sizeof(cred_buffer),
+		.msg_name = &sa_nl, .msg_namelen = sizeof(sa_nl)
+	};
 
 	/* read netlink message */
-	memset(buffer, 0, sizeof(buffer));
-	len = recvmsg(linux_netlink_socket, &meh, 0);
-	if (len < 32) {
-		if (errno != EAGAIN)
-			usbi_dbg("error recieving message from netlink");
+	len = recvmsg(linux_netlink_socket, &msg, 0);
+	if (len == -1) {
+		if (errno != EAGAIN && errno != EINTR)
+			usbi_err(NULL, "error receiving message from netlink (%d)", errno);
+		return -1;
+	}
+
+	if (len < 32 || (msg.msg_flags & MSG_TRUNC)) {
+		usbi_err(NULL, "invalid netlink message length");
 		return -1;
 	}
 
-	/* TODO -- authenticate this message is from the kernel or udevd */
+	if (sa_nl.nl_groups != NL_GROUP_KERNEL || sa_nl.nl_pid != 0) {
+		usbi_dbg("ignoring netlink message from unknown group/PID (%u/%u)",
+			 (unsigned int)sa_nl.nl_groups, (unsigned int)sa_nl.nl_pid);
+		return -1;
+	}
+
+	cmsg = CMSG_FIRSTHDR(&msg);
+	if (!cmsg || cmsg->cmsg_type != SCM_CREDENTIALS) {
+		usbi_dbg("ignoring netlink message with no sender credentials");
+		return -1;
+	}
 
-	r = linux_netlink_parse(buffer, len, &detached, &sys_name,
-				&busnum, &devaddr);
+	cred = (struct ucred *)CMSG_DATA(cmsg);
+	if (cred->uid != 0) {
+		usbi_dbg("ignoring netlink message with non-zero sender UID %u", (unsigned int)cred->uid);
+		return -1;
+	}
+
+	r = linux_netlink_parse(msg_buffer, (size_t)len, &detached, &sys_name, &busnum, &devaddr);
 	if (r)
 		return r;
 
@@ -317,7 +350,7 @@ static int linux_netlink_read_message(void)
 
 	/* signal device is available (or not) to all contexts */
 	if (detached)
-		linux_device_disconnected(busnum, devaddr, sys_name);
+		linux_device_disconnected(busnum, devaddr);
 	else
 		linux_hotplug_enumerate(busnum, devaddr, sys_name);
 
@@ -328,6 +361,7 @@ static void *linux_netlink_event_thread_main(void *arg)
 {
 	char dummy;
 	int r;
+	ssize_t nb;
 	struct pollfd fds[] = {
 		{ .fd = netlink_control_pipe[0],
 		  .events = POLLIN },
@@ -335,25 +369,31 @@ static void *linux_netlink_event_thread_main(void *arg)
 		  .events = POLLIN },
 	};
 
-	/* silence compiler warning */
-	(void) arg;
+	UNUSED(arg);
+
+	usbi_dbg("netlink event thread entering");
 
-	while (poll(fds, 2, -1) >= 0) {
+	while ((r = poll(fds, 2, -1)) >= 0 || errno == EINTR) {
+		if (r < 0) {
+			/* temporary failure */
+			continue;
+		}
 		if (fds[0].revents & POLLIN) {
 			/* activity on control pipe, read the byte and exit */
-			r = usbi_read(netlink_control_pipe[0], &dummy, sizeof(dummy));
-			if (r <= 0) {
+			nb = read(netlink_control_pipe[0], &dummy, sizeof(dummy));
+			if (nb <= 0)
 				usbi_warn(NULL, "netlink control pipe read failed");
-			}
 			break;
 		}
 		if (fds[1].revents & POLLIN) {
-        		usbi_mutex_static_lock(&linux_hotplug_lock);
-	        	linux_netlink_read_message();
-	        	usbi_mutex_static_unlock(&linux_hotplug_lock);
+			usbi_mutex_static_lock(&linux_hotplug_lock);
+			linux_netlink_read_message();
+			usbi_mutex_static_unlock(&linux_hotplug_lock);
 		}
 	}
 
+	usbi_dbg("netlink event thread exiting");
+
 	return NULL;
 }
 

package/libusb/libusb/os/linux_udev.c

@@ -20,7 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "config.h"
+#include <config.h>
 
 #include <assert.h>
 #include <ctype.h>
@@ -39,7 +39,6 @@
 #include <unistd.h>
 #include <libudev.h>
 
-#include "libusb.h"
 #include "libusbi.h"
 #include "linux_usbfs.h"
 
@@ -70,7 +69,7 @@ int linux_udev_start_event_monitor(void)
 		goto err_free_ctx;
 	}
 
-	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0);
+	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device");
 	if (r) {
 		usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem");
 		goto err_free_monitor;
@@ -83,17 +82,33 @@ int linux_udev_start_event_monitor(void)
 
 	udev_monitor_fd = udev_monitor_get_fd(udev_monitor);
 
+#if defined(FD_CLOEXEC)
+	/* Make sure the udev file descriptor is marked as CLOEXEC */
+	r = fcntl(udev_monitor_fd, F_GETFD);
+	if (r == -1) {
+		usbi_err(NULL, "geting udev monitor fd flags (%d)", errno);
+		goto err_free_monitor;
+	}
+	if (!(r & FD_CLOEXEC)) {
+		if (fcntl(udev_monitor_fd, F_SETFD, r | FD_CLOEXEC) == -1) {
+			usbi_err(NULL, "setting udev monitor fd flags (%d)", errno);
+			goto err_free_monitor;
+		}
+	}
+#endif
+
 	/* Some older versions of udev are not non-blocking by default,
 	 * so make sure this is set */
 	r = fcntl(udev_monitor_fd, F_GETFL);
 	if (r == -1) {
-		usbi_err(NULL, "getting udev monitor fd flags (%d)", errno);
+		usbi_err(NULL, "getting udev monitor fd status flags (%d)", errno);
 		goto err_free_monitor;
 	}
-	r = fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK);
-	if (r) {
-		usbi_err(NULL, "setting udev monitor fd flags (%d)", errno);
-		goto err_free_monitor;
+	if (!(r & O_NONBLOCK)) {
+		if (fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK) == -1) {
+			usbi_err(NULL, "setting udev monitor fd status flags (%d)", errno);
+			goto err_free_monitor;
+		}
 	}
 
 	r = usbi_pipe(udev_control_pipe);
@@ -135,7 +150,7 @@ int linux_udev_stop_event_monitor(void)
 
 	/* Write some dummy data to the control pipe and
 	 * wait for the thread to exit */
-	r = usbi_write(udev_control_pipe[1], &dummy, sizeof(dummy));
+	r = write(udev_control_pipe[1], &dummy, sizeof(dummy));
 	if (r <= 0) {
 		usbi_warn(NULL, "udev control pipe signal failed");
 	}
@@ -163,6 +178,7 @@ static void *linux_udev_event_thread_main(void *arg)
 {
 	char dummy;
 	int r;
+	ssize_t nb;
 	struct udev_device* udev_dev;
 	struct pollfd fds[] = {
 		{.fd = udev_control_pipe[0],
@@ -173,11 +189,15 @@ static void *linux_udev_event_thread_main(void *arg)
 
 	usbi_dbg("udev event thread entering.");
 
-	while (poll(fds, 2, -1) >= 0) {
+	while ((r = poll(fds, 2, -1)) >= 0 || errno == EINTR) {
+		if (r < 0) {
+			/* temporary failure */
+			continue;
+		}
 		if (fds[0].revents & POLLIN) {
 			/* activity on control pipe, read the byte and exit */
-			r = usbi_read(udev_control_pipe[0], &dummy, sizeof(dummy));
-			if (r <= 0) {
+			nb = read(udev_control_pipe[0], &dummy, sizeof(dummy));
+			if (nb <= 0) {
 				usbi_warn(NULL, "udev control pipe read failed");
 			}
 			break;
@@ -212,7 +232,7 @@ static int udev_device_info(struct libusb_context *ctx, int detached,
 	}
 
 	return linux_get_device_address(ctx, detached, busnum, devaddr,
-					dev_node, *sys_name);
+					dev_node, *sys_name, -1);
 }
 
 static void udev_hotplug_event(struct udev_device* udev_dev)
@@ -241,7 +261,7 @@ static void udev_hotplug_event(struct udev_device* udev_dev)
 		if (strncmp(udev_action, "add", 3) == 0) {
 			linux_hotplug_enumerate(busnum, devaddr, sys_name);
 		} else if (detached) {
-			linux_device_disconnected(busnum, devaddr, sys_name);
+			linux_device_disconnected(busnum, devaddr);
 		} else {
 			usbi_err(NULL, "ignoring udev action %s", udev_action);
 		}
@@ -267,9 +287,11 @@ int linux_udev_scan_devices(struct libusb_context *ctx)
 	}
 
 	udev_enumerate_add_match_subsystem(enumerator, "usb");
+	udev_enumerate_add_match_property(enumerator, "DEVTYPE", "usb_device");
 	udev_enumerate_scan_devices(enumerator);
 	devices = udev_enumerate_get_list_entry(enumerator);
 
+	entry = NULL;
 	udev_list_entry_foreach(entry, devices) {
 		const char *path = udev_list_entry_get_name(entry);
 		uint8_t busnum = 0, devaddr = 0;