-/*
- * libudev - interface to udev device information
- *
- * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
- *
- * 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 file is part of systemd.
+
+ Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
+
+ systemd 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.
+
+ systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
#include <stdio.h>
#include <stdlib.h>
#include "libudev.h"
#include "libudev-private.h"
#include "socket-util.h"
+#include "missing.h"
/**
* SECTION:libudev-monitor
{
struct udev_monitor *udev_monitor;
- udev_monitor = calloc(1, sizeof(struct udev_monitor));
+ udev_monitor = new0(struct udev_monitor, 1);
if (udev_monitor == NULL)
return NULL;
udev_monitor->refcount = 1;
return udev_monitor;
}
+/* we consider udev running when /dev is on devtmpfs */
+static bool udev_has_devtmpfs(struct udev *udev) {
+
+ union file_handle_union h = {
+ .handle.handle_bytes = MAX_HANDLE_SZ
+ };
+
+ _cleanup_fclose_ FILE *f = NULL;
+ char line[LINE_MAX], *e;
+ int mount_id;
+ int r;
+
+ r = name_to_handle_at(AT_FDCWD, "/dev", &h.handle, &mount_id, 0);
+ if (r < 0)
+ return false;
+
+ f = fopen("/proc/self/mountinfo", "re");
+ if (!f)
+ return false;
+
+ FOREACH_LINE(line, f, return false) {
+ int mid;
+
+ if (sscanf(line, "%i", &mid) != 1)
+ continue;
+
+ if (mid != mount_id)
+ continue;
+
+ e = strstr(line, " - ");
+ if (!e)
+ continue;
+
+ /* accept any name that starts with the currently expected type */
+ if (startswith(e + 3, "devtmpfs"))
+ return true;
+ }
+
+ return false;
+}
+
struct udev_monitor *udev_monitor_new_from_netlink_fd(struct udev *udev, const char *name, int fd)
{
struct udev_monitor *udev_monitor;
if (name == NULL)
group = UDEV_MONITOR_NONE;
- else if (strcmp(name, "udev") == 0)
- group = UDEV_MONITOR_UDEV;
- else if (strcmp(name, "kernel") == 0)
+ else if (streq(name, "udev")) {
+ /*
+ * We do not support subscribing to uevents if no instance of
+ * udev is running. Uevents would otherwise broadcast the
+ * processing data of the host into containers, which is not
+ * desired.
+ *
+ * Containers will currently not get any udev uevents, until
+ * a supporting infrastructure is available.
+ *
+ * We do not set a netlink multicast group here, so the socket
+ * will not receive any messages.
+ */
+ if (access("/run/udev/control", F_OK) < 0 && !udev_has_devtmpfs(udev)) {
+ udev_dbg(udev, "the udev service seems not to be active, disable the monitor\n");
+ group = UDEV_MONITOR_NONE;
+ } else
+ group = UDEV_MONITOR_UDEV;
+ } else if (streq(name, "kernel"))
group = UDEV_MONITOR_KERNEL;
else
return NULL;
udev_list_get_entry(&udev_monitor->filter_tag_list) == NULL)
return 0;
- memset(ins, 0x00, sizeof(ins));
+ memzero(ins, sizeof(ins));
i = 0;
/* load magic in A */
bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
if (i+1 >= ELEMENTSOF(ins))
- return -1;
+ return -E2BIG;
}
/* nothing matched, drop packet */
bpf_stmt(ins, &i, BPF_RET|BPF_K, 0xffffffff);
/* install filter */
- memset(&filter, 0x00, sizeof(filter));
+ memzero(&filter, sizeof(filter));
filter.len = i;
filter.filter = ins;
err = setsockopt(udev_monitor->sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter));
- return err;
+ return err < 0 ? -errno : 0;
}
int udev_monitor_allow_unicast_sender(struct udev_monitor *udev_monitor, struct udev_monitor *sender)
int err = 0;
const int on = 1;
- if (udev_monitor->snl.nl.nl_family == 0)
- return -EINVAL;
-
udev_monitor_filter_update(udev_monitor);
if (!udev_monitor->bound) {
udev_monitor->snl.nl.nl_pid = snl.nl.nl_pid;
} else {
udev_err(udev_monitor->udev, "bind failed: %m\n");
- return err;
+ return -errno;
}
/* enable receiving of sender credentials */
_public_ int udev_monitor_set_receive_buffer_size(struct udev_monitor *udev_monitor, int size)
{
if (udev_monitor == NULL)
- return -1;
+ return -EINVAL;
return setsockopt(udev_monitor->sock, SOL_SOCKET, SO_RCVBUFFORCE, &size, sizeof(size));
}
err = close(udev_monitor->sock);
udev_monitor->sock = -1;
- return err;
+ return err < 0 ? -errno : 0;
}
/**
* the bound socket will be closed, and the resources of the monitor
* will be released.
*
- * Returns: the passed udev monitor if it has still an active reference, or #NULL otherwise.
+ * Returns: #NULL
**/
_public_ struct udev_monitor *udev_monitor_unref(struct udev_monitor *udev_monitor)
{
return NULL;
udev_monitor->refcount--;
if (udev_monitor->refcount > 0)
- return udev_monitor;
+ return NULL;
if (udev_monitor->sock >= 0)
close(udev_monitor->sock);
udev_list_cleanup(&udev_monitor->filter_subsystem_list);
_public_ int udev_monitor_get_fd(struct udev_monitor *udev_monitor)
{
if (udev_monitor == NULL)
- return -1;
+ return -EINVAL;
return udev_monitor->sock;
}
const char *devtype;
const char *ddevtype;
- if (strcmp(dsubsys, subsys) != 0)
+ if (!streq(dsubsys, subsys))
continue;
devtype = udev_list_entry_get_value(list_entry);
ddevtype = udev_device_get_devtype(udev_device);
if (ddevtype == NULL)
continue;
- if (strcmp(ddevtype, devtype) == 0)
+ if (streq(ddevtype, devtype))
goto tag;
}
return 0;
*
* Only socket connections with uid=0 are accepted.
*
+ * The monitor socket is by default set to NONBLOCK. A variant of poll() on
+ * the file descriptor returned by udev_monitor_get_fd() should to be used to
+ * wake up when new devices arrive, or alternatively the file descriptor
+ * switched into blocking mode.
+ *
* The initial refcount is 1, and needs to be decremented to
* release the resources of the udev device.
*
char buf[8192];
ssize_t buflen;
ssize_t bufpos;
- struct udev_monitor_netlink_header *nlh;
retry:
if (udev_monitor == NULL)
return NULL;
iov.iov_base = &buf;
iov.iov_len = sizeof(buf);
- memset (&smsg, 0x00, sizeof(struct msghdr));
+ memzero(&smsg, sizeof(struct msghdr));
smsg.msg_iov = &iov;
smsg.msg_iovlen = 1;
smsg.msg_control = cred_msg;
smsg.msg_controllen = sizeof(cred_msg);
-
- if (udev_monitor->snl.nl.nl_family != 0) {
- smsg.msg_name = &snl;
- smsg.msg_namelen = sizeof(snl);
- }
+ smsg.msg_name = &snl;
+ smsg.msg_namelen = sizeof(snl);
buflen = recvmsg(udev_monitor->sock, &smsg, 0);
if (buflen < 0) {
return NULL;
}
- if (udev_monitor->snl.nl.nl_family != 0) {
- if (snl.nl.nl_groups == 0) {
- /* unicast message, check if we trust the sender */
- if (udev_monitor->snl_trusted_sender.nl.nl_pid == 0 ||
- snl.nl.nl_pid != udev_monitor->snl_trusted_sender.nl.nl_pid) {
- udev_dbg(udev_monitor->udev, "unicast netlink message ignored\n");
- return NULL;
- }
- } else if (snl.nl.nl_groups == UDEV_MONITOR_KERNEL) {
- if (snl.nl.nl_pid > 0) {
- udev_dbg(udev_monitor->udev, "multicast kernel netlink message from pid %d ignored\n",
- snl.nl.nl_pid);
- return NULL;
- }
+ if (snl.nl.nl_groups == 0) {
+ /* unicast message, check if we trust the sender */
+ if (udev_monitor->snl_trusted_sender.nl.nl_pid == 0 ||
+ snl.nl.nl_pid != udev_monitor->snl_trusted_sender.nl.nl_pid) {
+ udev_dbg(udev_monitor->udev, "unicast netlink message ignored\n");
+ return NULL;
+ }
+ } else if (snl.nl.nl_groups == UDEV_MONITOR_KERNEL) {
+ if (snl.nl.nl_pid > 0) {
+ udev_dbg(udev_monitor->udev, "multicast kernel netlink message from pid %d ignored\n",
+ snl.nl.nl_pid);
+ return NULL;
}
}
return NULL;
}
+ udev_device = udev_device_new(udev_monitor->udev);
+ if (udev_device == NULL)
+ return NULL;
+
if (memcmp(buf, "libudev", 8) == 0) {
+ struct udev_monitor_netlink_header *nlh;
+
/* udev message needs proper version magic */
nlh = (struct udev_monitor_netlink_header *) buf;
if (nlh->magic != htonl(UDEV_MONITOR_MAGIC)) {
udev_err(udev_monitor->udev, "unrecognized message signature (%x != %x)\n",
- nlh->magic, htonl(UDEV_MONITOR_MAGIC));
+ nlh->magic, htonl(UDEV_MONITOR_MAGIC));
+ udev_device_unref(udev_device);
return NULL;
}
- if (nlh->properties_off+32 > buflen)
+ if (nlh->properties_off+32 > (size_t)buflen) {
+ udev_device_unref(udev_device);
return NULL;
+ }
+
bufpos = nlh->properties_off;
+
+ /* devices received from udev are always initialized */
+ udev_device_set_is_initialized(udev_device);
} else {
/* kernel message with header */
bufpos = strlen(buf) + 1;
if ((size_t)bufpos < sizeof("a@/d") || bufpos >= buflen) {
udev_dbg(udev_monitor->udev, "invalid message length\n");
+ udev_device_unref(udev_device);
return NULL;
}
/* check message header */
if (strstr(buf, "@/") == NULL) {
udev_dbg(udev_monitor->udev, "unrecognized message header\n");
+ udev_device_unref(udev_device);
return NULL;
}
}
- udev_device = udev_device_new(udev_monitor->udev);
- if (udev_device == NULL)
- return NULL;
udev_device_set_info_loaded(udev_device);
while (bufpos < buflen) {
struct udev_list_entry *list_entry;
uint64_t tag_bloom_bits;
- if (udev_monitor->snl.nl.nl_family == 0)
- return -EINVAL;
-
blen = udev_device_get_properties_monitor_buf(udev_device, &buf);
if (blen < 32)
return -EINVAL;
/* add versioned header */
- memset(&nlh, 0x00, sizeof(struct udev_monitor_netlink_header));
+ memzero(&nlh, sizeof(struct udev_monitor_netlink_header));
memcpy(nlh.prefix, "libudev", 8);
nlh.magic = htonl(UDEV_MONITOR_MAGIC);
nlh.header_size = sizeof(struct udev_monitor_netlink_header);
iov[1].iov_base = (char *)buf;
iov[1].iov_len = blen;
- memset(&smsg, 0x00, sizeof(struct msghdr));
+ memzero(&smsg, sizeof(struct msghdr));
smsg.msg_iov = iov;
smsg.msg_iovlen = 2;
/*
~ianmdlvl / elogind.git / blobdiff