X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Flib%2Flibudev-monitor.c;h=d8b375c713d41bea120c9e9af5e63128d71630c4;hp=a8b1a4e2e51195a6dd71e04776d6400bdf0a70e4;hb=dacea9ff6be55f1b115c13b1ab530812d0d66879;hpb=4b09a2fc4383f191d96a8d6134b95a4b84aef931

diff --git a/udev/lib/libudev-monitor.c b/udev/lib/libudev-monitor.c
index a8b1a4e2e..d8b375c71 100644
--- a/udev/lib/libudev-monitor.c
+++ b/udev/lib/libudev-monitor.c
@@ -16,10 +16,13 @@
 #include <errno.h>
 #include <string.h>
 #include <dirent.h>
+#include <sys/poll.h>
 #include <sys/stat.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <arpa/inet.h>
 #include <linux/netlink.h>
+#include <linux/filter.h>
 
 #include "libudev.h"
 #include "libudev-private.h"
@@ -32,6 +35,7 @@ struct udev_monitor {
 	struct sockaddr_nl snl_peer;
 	struct sockaddr_un sun;
 	socklen_t addrlen;
+	struct udev_list_node filter_subsystem_list;
 };
 
 enum udev_monitor_netlink_group {
@@ -39,18 +43,55 @@ enum udev_monitor_netlink_group {
 	UDEV_MONITOR_UDEV	= 2,
 };
 
+#define UDEV_MONITOR_MAGIC		0xcafe1dea
+struct udev_monitor_netlink_header {
+	/* udev version text */
+	char version[16];
+	/*
+	 * magic to protect against daemon <-> library message format mismatch
+	 * used in the kernel from socket filter rules; needs to be stored in network order
+	 */
+	unsigned int magic;
+	/* properties buffer */
+	unsigned short properties_off;
+	unsigned short properties_len;
+	/*
+	 * hashes of some common device properties strings to filter with socket filters in
+	 * the client used in the kernel from socket filter rules; needs to be stored in
+	 * network order
+	 */
+	unsigned int filter_subsystem;
+	unsigned int filter_devtype;
+};
+
+static struct udev_monitor *udev_monitor_new(struct udev *udev)
+{
+	struct udev_monitor *udev_monitor;
+
+	udev_monitor = calloc(1, sizeof(struct udev_monitor));
+	if (udev_monitor == NULL)
+		return NULL;
+	udev_monitor->refcount = 1;
+	udev_monitor->udev = udev;
+	udev_list_init(&udev_monitor->filter_subsystem_list);
+	return udev_monitor;
+}
+
 /**
  * udev_monitor_new_from_socket:
  * @udev: udev library context
  * @socket_path: unix socket path
  *
- * Create new udev monitor, setup and connect to a specified socket. The
- * path to a socket can point to an existing socket file, or it will be
- * created if needed. If neccessary, the permissions adjustment as well as
- * the later cleanup of the socket file, needs to be done by the caller.
- * If the socket path starts with a '@' character, an abstract namespace
+ * Create new udev monitor and connect to a specified socket. The
+ * path to a socket either points to an existing socket file, or if
+ * the socket path starts with a '@' character, an abstract namespace
  * socket will be used.
  *
+ * A socket file will not be created. If it does not already exist,
+ * it will fall-back and connect to an abstract namespace socket with
+ * the given path. The permissions adjustment of a socket file, as
+ * well as the later cleanup, needs to be done by the caller.
+ *
  * The initial refcount is 1, and needs to be decremented to
  * release the resources of the udev monitor.
  *
@@ -65,11 +106,9 @@ struct udev_monitor *udev_monitor_new_from_socket(struct udev *udev, const char
 		return NULL;
 	if (socket_path == NULL)
 		return NULL;
-	udev_monitor = calloc(1, sizeof(struct udev_monitor));
+	udev_monitor = udev_monitor_new(udev);
 	if (udev_monitor == NULL)
 		return NULL;
-	udev_monitor->refcount = 1;
-	udev_monitor->udev = udev;
 
 	udev_monitor->sun.sun_family = AF_LOCAL;
 	if (socket_path[0] == '@') {
@@ -98,6 +137,31 @@ struct udev_monitor *udev_monitor_new_from_socket(struct udev *udev, const char
 	return udev_monitor;
 }
 
+/**
+ * udev_monitor_new_from_netlink:
+ * @udev: udev library context
+ * @name: name of event source
+ *
+ * Create new udev monitor and connect to a specified event
+ * source. Valid sources identifiers are "udev" and "kernel".
+ *
+ * Applications should usually not connect directly to the
+ * "kernel" events, because the devices might not be useable
+ * at that time, before udev has configured them, and created
+ * device nodes.
+ *
+ * Accessing devices at the same time as udev, might result
+ * in unpredictable behavior.
+ *
+ * The "udev" events are sent out after udev has finished its
+ * event processing, all rules have been processed, and needed
+ * device nodes are created.
+ *
+ * The initial refcount is 1, and needs to be decremented to
+ * release the resources of the udev monitor.
+ *
+ * Returns: a new udev monitor, or #NULL, in case of an error
+ **/
 struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char *name)
 {
 	struct udev_monitor *udev_monitor;
@@ -115,11 +179,9 @@ struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char
 	else
 		return NULL;
 
-	udev_monitor = calloc(1, sizeof(struct udev_monitor));
+	udev_monitor = udev_monitor_new(udev);
 	if (udev_monitor == NULL)
 		return NULL;
-	udev_monitor->refcount = 1;
-	udev_monitor->udev = udev;
 
 	udev_monitor->sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
 	if (udev_monitor->sock == -1) {
@@ -138,30 +200,110 @@ struct udev_monitor *udev_monitor_new_from_netlink(struct udev *udev, const char
 	return udev_monitor;
 }
 
+static inline void bpf_stmt(struct sock_filter *inss, unsigned int *i,
+			    unsigned short code, unsigned int data)
+{
+	struct sock_filter *ins = &inss[*i];
+
+	ins->code = code;
+	ins->k = data;
+	(*i)++;
+}
+
+static inline void bpf_jmp(struct sock_filter *inss, unsigned int *i,
+			   unsigned short code, unsigned int data,
+			   unsigned short jt, unsigned short jf)
+{
+	struct sock_filter *ins = &inss[*i];
+
+	ins->code = code;
+	ins->jt = jt;
+	ins->jf = jf;
+	ins->k = data;
+	(*i)++;
+}
+
+static int filter_apply(struct udev_monitor *udev_monitor)
+{
+	static struct sock_filter ins[256];
+	static struct sock_fprog filter;
+	unsigned int i;
+	struct udev_list_entry *list_entry;
+	int err;
+
+	if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL)
+		return 0;
+
+	memset(ins, 0x00, sizeof(ins));
+	i = 0;
+
+	/* load magic in A */
+	bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, magic));
+	/* jump if magic matches */
+	bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, UDEV_MONITOR_MAGIC, 1, 0);
+	/* wrong magic, drop packet */
+	bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
+
+	/* add all subsystem match values */
+	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
+		unsigned int hash;
+
+		/* load filter_subsystem value in A */
+		bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_subsystem));
+		hash = util_string_hash32(udev_list_entry_get_name(list_entry));
+		if (udev_list_entry_get_value(list_entry) == NULL) {
+			/* jump if subsystem does not match */
+			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
+		} else {
+			/* jump if subsystem does not match */
+			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 3);
+
+			/* load filter_devtype value in A */
+			bpf_stmt(ins, &i, BPF_LD|BPF_W|BPF_ABS, offsetof(struct udev_monitor_netlink_header, filter_devtype));
+			/* jump if value does not match */
+			hash = util_string_hash32(udev_list_entry_get_value(list_entry));
+			bpf_jmp(ins, &i, BPF_JMP|BPF_JEQ|BPF_K, hash, 0, 1);
+		}
+
+		/* matched, pass packet */
+		bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
+
+		if (i+1 >= ARRAY_SIZE(ins))
+			return -1;
+	}
+	/* nothing matched, drop packet */
+	bpf_stmt(ins, &i, BPF_RET|BPF_K, 0);
+
+	/* install filter */
+	filter.len = i;
+	filter.filter = ins;
+	err = setsockopt(udev_monitor->sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
+	return err;
+}
+
 int udev_monitor_enable_receiving(struct udev_monitor *udev_monitor)
 {
 	int err;
 	const int on = 1;
 
-	if (udev_monitor->snl.nl_family != 0) {
-		err = bind(udev_monitor->sock,
-			   (struct sockaddr *)&udev_monitor->snl, sizeof(struct sockaddr_nl));
-		if (err < 0) {
-			err(udev_monitor->udev, "bind failed: %m\n");
-			return err;
-		}
-		dbg(udev_monitor->udev, "monitor %p listening on netlink\n", udev_monitor);
-	} else if (udev_monitor->sun.sun_family != 0) {
+	if (udev_monitor->sun.sun_family != 0) {
 		err = bind(udev_monitor->sock,
 			   (struct sockaddr *)&udev_monitor->sun, udev_monitor->addrlen);
-		if (err < 0) {
-			err(udev_monitor->udev, "bind failed: %m\n");
-			return err;
-		}
-		/* enable receiving of the sender credentials */
-		setsockopt(udev_monitor->sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));
-		dbg(udev_monitor->udev, "monitor %p listening on socket\n", udev_monitor);
+	} else if (udev_monitor->snl.nl_family != 0) {
+		filter_apply(udev_monitor);
+		err = bind(udev_monitor->sock,
+			   (struct sockaddr *)&udev_monitor->snl, sizeof(struct sockaddr_nl));
+	} else {
+		return -EINVAL;
 	}
+
+	if (err < 0) {
+		err(udev_monitor->udev, "bind failed: %m\n");
+		return err;
+	}
+
+	/* enable receiving of sender credentials */
+	setsockopt(udev_monitor->sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));
 	return 0;
 }
 
@@ -192,7 +334,7 @@ struct udev_monitor *udev_monitor_ref(struct udev_monitor *udev_monitor)
  * udev_monitor_unref:
  * @udev_monitor: udev monitor
  *
- * Drop a reference ofa udev monitor. If the refcount reaches zero,
+ * Drop a reference of a udev monitor. If the refcount reaches zero,
  * the bound socket will be closed, and the resources of the monitor
  * will be released.
  *
@@ -206,6 +348,7 @@ void udev_monitor_unref(struct udev_monitor *udev_monitor)
 		return;
 	if (udev_monitor->sock >= 0)
 		close(udev_monitor->sock);
+	udev_list_cleanup_entries(udev_monitor->udev, &udev_monitor->filter_subsystem_list);
 	dbg(udev_monitor->udev, "monitor %p released\n", udev_monitor);
 	free(udev_monitor);
 }
@@ -240,6 +383,34 @@ int udev_monitor_get_fd(struct udev_monitor *udev_monitor)
 	return udev_monitor->sock;
 }
 
+static int passes_filter(struct udev_monitor *udev_monitor, struct udev_device *udev_device)
+{
+	struct udev_list_entry *list_entry;
+
+	if (udev_list_get_entry(&udev_monitor->filter_subsystem_list) == NULL)
+		return 1;
+
+	udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_monitor->filter_subsystem_list)) {
+		const char *subsys = udev_list_entry_get_name(list_entry);
+		const char *dsubsys = udev_device_get_subsystem(udev_device);
+		const char *devtype;
+		const char *ddevtype;
+
+		if (strcmp(dsubsys, subsys) != 0)
+			continue;
+
+		devtype = udev_list_entry_get_value(list_entry);
+		if (devtype == NULL)
+			return 1;
+		ddevtype = udev_device_get_devtype(udev_device);
+		if (ddevtype == NULL)
+			continue;
+		if (strcmp(ddevtype, devtype) == 0)
+			return 1;
+	}
+	return 0;
+}
+
 /**
  * udev_monitor_receive_device:
  * @udev_monitor: udev monitor
@@ -262,14 +433,20 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito
 	struct msghdr smsg;
 	struct iovec iov;
 	char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
-	char buf[4096];
-	size_t bufpos;
+	struct cmsghdr *cmsg;
+	struct sockaddr_nl snl;
+	struct ucred *cred;
+	char buf[8192];
+	ssize_t buflen;
+	ssize_t bufpos;
+	struct udev_monitor_netlink_header *nlh;
 	int devpath_set = 0;
 	int subsystem_set = 0;
 	int action_set = 0;
 	int maj = 0;
 	int min = 0;
 
+retry:
 	if (udev_monitor == NULL)
 		return NULL;
 	memset(buf, 0x00, sizeof(buf));
@@ -281,46 +458,77 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito
 	smsg.msg_control = cred_msg;
 	smsg.msg_controllen = sizeof(cred_msg);
 
-	if (recvmsg(udev_monitor->sock, &smsg, 0) < 0) {
+	if (udev_monitor->snl.nl_family != 0) {
+		smsg.msg_name = &snl;
+		smsg.msg_namelen = sizeof(snl);
+	}
+
+	buflen = recvmsg(udev_monitor->sock, &smsg, 0);
+	if (buflen < 0) {
 		if (errno != EINTR)
-			info(udev_monitor->udev, "unable to receive message");
+			info(udev_monitor->udev, "unable to receive message\n");
 		return NULL;
 	}
 
-	if (udev_monitor->sun.sun_family != 0) {
-		struct cmsghdr *cmsg = CMSG_FIRSTHDR(&smsg);
-		struct ucred *cred = (struct ucred *)CMSG_DATA (cmsg);
+	if (buflen < 32 || (size_t)buflen >= sizeof(buf)) {
+		info(udev_monitor->udev, "invalid message length\n");
+		return NULL;
+	}
 
-		if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {
-			info(udev_monitor->udev, "no sender credentials received, message ignored");
+	if (udev_monitor->snl.nl_family != 0) {
+		if (snl.nl_groups == 0) {
+			info(udev_monitor->udev, "unicast netlink message ignored\n");
 			return NULL;
 		}
-
-		if (cred->uid != 0) {
-			info(udev_monitor->udev, "sender uid=%d, message ignored", cred->uid);
+		if ((snl.nl_groups == UDEV_MONITOR_KERNEL) && (snl.nl_pid > 0)) {
+			info(udev_monitor->udev, "multicast kernel netlink message from pid %d ignored\n", snl.nl_pid);
 			return NULL;
 		}
 	}
 
-	/* skip header */
-	bufpos = strlen(buf) + 1;
-	if (bufpos < sizeof("a@/d") || bufpos >= sizeof(buf)) {
-		info(udev_monitor->udev, "invalid message length");
+	cmsg = CMSG_FIRSTHDR(&smsg);
+	if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {
+		info(udev_monitor->udev, "no sender credentials received, message ignored\n");
 		return NULL;
 	}
 
-	/* check message header */
-	if (strstr(buf, "@/") == NULL) {
-		info(udev_monitor->udev, "unrecognized message header");
+	cred = (struct ucred *)CMSG_DATA(cmsg);
+	if (cred->uid != 0) {
+		info(udev_monitor->udev, "sender uid=%d, message ignored\n", cred->uid);
 		return NULL;
 	}
 
+	if (strncmp(buf, "udev-", 5) == 0) {
+		/* udev message needs proper version magic */
+		nlh = (struct udev_monitor_netlink_header *) buf;
+		if (nlh->magic != htonl(UDEV_MONITOR_MAGIC))
+			return NULL;
+		if (nlh->properties_off < sizeof(struct udev_monitor_netlink_header))
+			return NULL;
+		if (nlh->properties_off+32U > buflen)
+			return NULL;
+		bufpos = nlh->properties_off;
+	} else {
+		/* kernel message with header */
+		bufpos = strlen(buf) + 1;
+		if ((size_t)bufpos < sizeof("a@/d") || bufpos >= buflen) {
+			info(udev_monitor->udev, "invalid message length\n");
+			return NULL;
+		}
+
+		/* check message header */
+		if (strstr(buf, "@/") == NULL) {
+			info(udev_monitor->udev, "unrecognized message header\n");
+			return NULL;
+		}
+	}
+
 	udev_device = device_new(udev_monitor->udev);
 	if (udev_device == NULL) {
 		return NULL;
 	}
 
-	while (bufpos < sizeof(buf)) {
+	while (bufpos < buflen) {
 		char *key;
 		size_t keylen;
 
@@ -389,6 +597,23 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito
 		udev_device_unref(udev_device);
 		return NULL;
 	}
+
+	/* skip device, if it does not pass the current filter */
+	if (!passes_filter(udev_monitor, udev_device)) {
+		struct pollfd pfd[1];
+		int rc;
+
+		udev_device_unref(udev_device);
+
+		/* if something is queued, get next device */
+		pfd[0].fd = udev_monitor->sock;
+		pfd[0].events = POLLIN;
+		rc = poll(pfd, 1, 0);
+		if (rc > 0)
+			goto retry;
+		return NULL;
+	}
+
 	if (maj > 0)
 		udev_device_set_devnum(udev_device, makedev(maj, min));
 	udev_device_set_info_loaded(udev_device);
@@ -397,25 +622,88 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito
 
 int udev_monitor_send_device(struct udev_monitor *udev_monitor, struct udev_device *udev_device)
 {
+	struct msghdr smsg;
+	struct iovec iov[2];
 	const char *buf;
-	ssize_t len;
+	ssize_t blen;
 	ssize_t count;
 
-	len = udev_device_get_properties_monitor_buf(udev_device, &buf);
-	if (len < 32)
+	blen = udev_device_get_properties_monitor_buf(udev_device, &buf);
+	if (blen < 32)
 		return -1;
+
 	if (udev_monitor->sun.sun_family != 0) {
-		count = sendto(udev_monitor->sock,
-			       buf, len, 0,
-			       (struct sockaddr *)&udev_monitor->sun,
-			       udev_monitor->addrlen);
+		const char *action;
+		char header[2048];
+		size_t hlen;
+
+		/* header <action>@<devpath> */
+		action = udev_device_get_action(udev_device);
+		if (action == NULL)
+			return -EINVAL;
+		util_strlcpy(header, action, sizeof(header));
+		util_strlcat(header, "@", sizeof(header));
+		hlen = util_strlcat(header, udev_device_get_devpath(udev_device), sizeof(header))+1;
+		if (hlen >= sizeof(header))
+			return -EINVAL;
+		iov[0].iov_base = header;
+		iov[0].iov_len = hlen;
+
+		/* add properties list */
+		iov[1].iov_base = (char *)buf;
+		iov[1].iov_len = blen;
+
+		memset(&smsg, 0x00, sizeof(struct msghdr));
+		smsg.msg_iov = iov;
+		smsg.msg_iovlen = 2;
+		smsg.msg_name = &udev_monitor->sun;
+		smsg.msg_namelen = udev_monitor->addrlen;
+	} else if (udev_monitor->snl.nl_family != 0) {
+		const char *val;
+		struct udev_monitor_netlink_header nlh;
+
+
+		/* add versioned header */
+		memset(&nlh, 0x00, sizeof(struct udev_monitor_netlink_header));
+		util_strlcpy(nlh.version, "udev-" VERSION, sizeof(nlh.version));
+		nlh.magic = htonl(UDEV_MONITOR_MAGIC);
+		val = udev_device_get_subsystem(udev_device);
+		nlh.filter_subsystem = htonl(util_string_hash32(val));
+		val = udev_device_get_devtype(udev_device);
+		if (val != NULL)
+			nlh.filter_devtype = htonl(util_string_hash32(val));
+		iov[0].iov_base = &nlh;
+		iov[0].iov_len = sizeof(struct udev_monitor_netlink_header);
+
+		/* add properties list */
+		nlh.properties_off = iov[0].iov_len;
+		nlh.properties_len = blen;
+		iov[1].iov_base = (char *)buf;
+		iov[1].iov_len = blen;
+
+		memset(&smsg, 0x00, sizeof(struct msghdr));
+		smsg.msg_iov = iov;
+		smsg.msg_iovlen = 2;
+		/* no destination besides the muticast group, we will always get ECONNREFUSED */
+		smsg.msg_name = &udev_monitor->snl_peer;
+		smsg.msg_namelen = sizeof(struct sockaddr_nl);
 	} else {
-		/* no destination besides the muticast group, we will always get -1 ECONNREFUSED */
-		count = sendto(udev_monitor->sock,
-			       buf, len, 0,
-			       (struct sockaddr *)&udev_monitor->snl_peer,
-			       sizeof(struct sockaddr_nl));
+		return -1;
 	}
-	info(udev_monitor->udev, "passed %zi bytes to monitor %p, \n", count, udev_monitor);
+
+	count = sendmsg(udev_monitor->sock, &smsg, 0);
+	info(udev_monitor->udev, "passed %zi bytes to monitor %p\n", count, udev_monitor);
 	return count;
 }
+
+int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_monitor, const char *subsystem, const char *devtype)
+{
+	if (udev_monitor == NULL)
+		return -EINVAL;
+	if (subsystem == NULL)
+		return 0;
+	if (udev_list_entry_add(udev_monitor->udev,
+				&udev_monitor->filter_subsystem_list, subsystem, devtype, 0, 0) == NULL)
+		return -ENOMEM;
+	return 0;
+}