/*
- * Copyright (C) 2003-2010 Kay Sievers <kay@vrfy.org>
+ * Copyright (C) 2003-2013 Kay Sievers <kay@vrfy.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include <string.h>
#include <time.h>
#include <net/if.h>
-#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <sys/poll.h>
#include <sys/epoll.h>
#include <sys/wait.h>
-#include <sys/socket.h>
#include <sys/signalfd.h>
-#include <linux/sockios.h>
#include "udev.h"
+#include "rtnl-util.h"
-struct udev_event *udev_event_new(struct udev_device *dev)
-{
+struct udev_event *udev_event_new(struct udev_device *dev) {
struct udev *udev = udev_device_get_udev(dev);
struct udev_event *event;
- event = calloc(1, sizeof(struct udev_event));
+ event = new0(struct udev_event, 1);
if (event == NULL)
return NULL;
event->dev = dev;
event->udev = udev;
udev_list_init(udev, &event->run_list, false);
+ udev_list_init(udev, &event->seclabel_list, false);
event->fd_signal = -1;
event->birth_usec = now(CLOCK_MONOTONIC);
- event->timeout_usec = 30 * 1000 * 1000;
return event;
}
-void udev_event_unref(struct udev_event *event)
-{
+void udev_event_unref(struct udev_event *event) {
if (event == NULL)
return;
udev_list_cleanup(&event->run_list);
+ udev_list_cleanup(&event->seclabel_list);
free(event->program_result);
free(event->name);
free(event);
}
-size_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size)
-{
+size_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size) {
struct udev_device *dev = event->dev;
enum subst_type {
SUBST_UNKNOWN,
from++;
for (i = 0; from[i] != '}'; i++) {
if (from[i] == '\0') {
- log_error("missing closing brace for format '%s'\n", src);
+ log_error("missing closing brace for format '%s'", src);
goto out;
}
}
cpos++;
while (isspace(cpos[0]))
cpos++;
+ if (cpos[0] == '\0')
+ break;
}
if (i > 0) {
- log_error("requested part of result string not found\n");
+ log_error("requested part of result string not found");
break;
}
strscpy(tmp, sizeof(tmp), cpos);
int count;
if (attr == NULL) {
- log_error("missing file parameter for attr\n");
+ log_error("missing file parameter for attr");
break;
}
vbuf[len] = '\0';
count = util_replace_chars(vbuf, UDEV_ALLOWED_CHARS_INPUT);
if (count > 0)
- log_debug("%i character(s) replaced\n" , count);
+ log_debug("%i character(s) replaced" , count);
l = strpcpy(&s, l, vbuf);
break;
}
break;
}
default:
- log_error("unknown substitution type=%i\n", type);
+ log_error("unknown substitution type=%i", type);
break;
}
}
static int spawn_exec(struct udev_event *event,
const char *cmd, char *const argv[], char **envp, const sigset_t *sigmask,
- int fd_stdout, int fd_stderr)
-{
+ int fd_stdout, int fd_stderr) {
int err;
int fd;
dup2(fd, STDERR_FILENO);
close(fd);
} else {
- log_error("open /dev/null failed: %m\n");
+ log_error("open /dev/null failed: %m");
}
/* connect pipes to std{out,err} */
/* exec failed */
err = -errno;
- log_error("failed to execute '%s' '%s': %m\n", argv[0], cmd);
+ log_error("failed to execute '%s' '%s': %m", argv[0], cmd);
return err;
}
static void spawn_read(struct udev_event *event,
- const char *cmd,
- int fd_stdout, int fd_stderr,
- char *result, size_t ressize)
-{
+ usec_t timeout_usec,
+ const char *cmd,
+ int fd_stdout, int fd_stderr,
+ char *result, size_t ressize) {
size_t respos = 0;
int fd_ep = -1;
struct epoll_event ep_outpipe, ep_errpipe;
fd_ep = epoll_create1(EPOLL_CLOEXEC);
if (fd_ep < 0) {
- log_error("error creating epoll fd: %m\n");
+ log_error("error creating epoll fd: %m");
goto out;
}
if (fd_stdout >= 0) {
- memset(&ep_outpipe, 0, sizeof(struct epoll_event));
+ memzero(&ep_outpipe, sizeof(struct epoll_event));
ep_outpipe.events = EPOLLIN;
ep_outpipe.data.ptr = &fd_stdout;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe) < 0) {
- log_error("fail to add fd to epoll: %m\n");
+ log_error("fail to add fd to epoll: %m");
goto out;
}
}
if (fd_stderr >= 0) {
- memset(&ep_errpipe, 0, sizeof(struct epoll_event));
+ memzero(&ep_errpipe, sizeof(struct epoll_event));
ep_errpipe.events = EPOLLIN;
ep_errpipe.data.ptr = &fd_stderr;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe) < 0) {
- log_error("fail to add fd to epoll: %m\n");
+ log_error("fail to add fd to epoll: %m");
goto out;
}
}
struct epoll_event ev[4];
int i;
- if (event->timeout_usec > 0) {
+ if (timeout_usec > 0) {
usec_t age_usec;
age_usec = now(CLOCK_MONOTONIC) - event->birth_usec;
- if (age_usec >= event->timeout_usec) {
- log_error("timeout '%s'\n", cmd);
+ if (age_usec >= timeout_usec) {
+ log_error("timeout '%s'", cmd);
goto out;
}
- timeout = ((event->timeout_usec - age_usec) / 1000) + 1000;
+ timeout = ((timeout_usec - age_usec) / USEC_PER_MSEC) + MSEC_PER_SEC;
} else {
timeout = -1;
}
if (fdcount < 0) {
if (errno == EINTR)
continue;
- log_error("failed to poll: %m\n");
+ log_error("failed to poll: %m");
goto out;
}
if (fdcount == 0) {
- log_error("timeout '%s'\n", cmd);
+ log_error("timeout '%s'", cmd);
goto out;
}
memcpy(&result[respos], buf, count);
respos += count;
} else {
- log_error("'%s' ressize %zd too short\n", cmd, ressize);
+ log_error("'%s' ressize %zd too short", cmd, ressize);
}
}
pos = buf;
while ((line = strsep(&pos, "\n"))) {
if (pos != NULL || line[0] != '\0')
- log_debug("'%s'(%s) '%s'\n", cmd, *fd == fd_stdout ? "out" : "err" , line);
+ log_debug("'%s'(%s) '%s'", cmd, *fd == fd_stdout ? "out" : "err" , line);
}
}
} else if (ev[i].events & EPOLLHUP) {
if (epoll_ctl(fd_ep, EPOLL_CTL_DEL, *fd, NULL) < 0) {
- log_error("failed to remove fd from epoll: %m\n");
+ log_error("failed to remove fd from epoll: %m");
goto out;
}
*fd = -1;
close(fd_ep);
}
-static int spawn_wait(struct udev_event *event, const char *cmd, pid_t pid)
-{
+static int spawn_wait(struct udev_event *event,
+ usec_t timeout_usec,
+ const char *cmd, pid_t pid) {
struct pollfd pfd[1];
int err = 0;
int timeout;
int fdcount;
- if (event->timeout_usec > 0) {
+ if (timeout_usec > 0) {
usec_t age_usec;
age_usec = now(CLOCK_MONOTONIC) - event->birth_usec;
- if (age_usec >= event->timeout_usec)
+ if (age_usec >= timeout_usec)
timeout = 1000;
else
- timeout = ((event->timeout_usec - age_usec) / 1000) + 1000;
+ timeout = ((timeout_usec - age_usec) / USEC_PER_MSEC) + MSEC_PER_SEC;
} else {
timeout = -1;
}
if (errno == EINTR)
continue;
err = -errno;
- log_error("failed to poll: %m\n");
+ log_error("failed to poll: %m");
goto out;
}
if (fdcount == 0) {
- log_error("timeout: killing '%s' [%u]\n", cmd, pid);
+ log_error("timeout: killing '%s' [%u]", cmd, pid);
kill(pid, SIGKILL);
}
if (waitpid(pid, &status, WNOHANG) < 0)
break;
if (WIFEXITED(status)) {
- log_debug("'%s' [%u] exit with return code %i\n", cmd, pid, WEXITSTATUS(status));
+ log_debug("'%s' [%u] exit with return code %i", cmd, pid, WEXITSTATUS(status));
if (WEXITSTATUS(status) != 0)
err = -1;
} else if (WIFSIGNALED(status)) {
- log_error("'%s' [%u] terminated by signal %i (%s)\n", cmd, pid, WTERMSIG(status), strsignal(WTERMSIG(status)));
+ log_error("'%s' [%u] terminated by signal %i (%s)", cmd, pid, WTERMSIG(status), strsignal(WTERMSIG(status)));
err = -1;
} else if (WIFSTOPPED(status)) {
- log_error("'%s' [%u] stopped\n", cmd, pid);
+ log_error("'%s' [%u] stopped", cmd, pid);
err = -1;
} else if (WIFCONTINUED(status)) {
- log_error("'%s' [%u] continued\n", cmd, pid);
+ log_error("'%s' [%u] continued", cmd, pid);
err = -1;
} else {
- log_error("'%s' [%u] exit with status 0x%04x\n", cmd, pid, status);
+ log_error("'%s' [%u] exit with status 0x%04x", cmd, pid, status);
err = -1;
}
pid = 0;
return err;
}
-int udev_build_argv(struct udev *udev, char *cmd, int *argc, char *argv[])
-{
+int udev_build_argv(struct udev *udev, char *cmd, int *argc, char *argv[]) {
int i = 0;
char *pos;
}
int udev_event_spawn(struct udev_event *event,
+ usec_t timeout_usec,
const char *cmd, char **envp, const sigset_t *sigmask,
- char *result, size_t ressize)
-{
+ char *result, size_t ressize) {
struct udev *udev = event->udev;
int outpipe[2] = {-1, -1};
int errpipe[2] = {-1, -1};
if (result != NULL || udev_get_log_priority(udev) >= LOG_INFO) {
if (pipe2(outpipe, O_NONBLOCK) != 0) {
err = -errno;
- log_error("pipe failed: %m\n");
+ log_error("pipe failed: %m");
goto out;
}
}
if (udev_get_log_priority(udev) >= LOG_INFO) {
if (pipe2(errpipe, O_NONBLOCK) != 0) {
err = -errno;
- log_error("pipe failed: %m\n");
+ log_error("pipe failed: %m");
goto out;
}
}
errpipe[READ_END] = -1;
}
- log_debug("starting '%s'\n", cmd);
+ log_debug("starting '%s'", cmd);
spawn_exec(event, cmd, argv, envp, sigmask,
outpipe[WRITE_END], errpipe[WRITE_END]);
_exit(2 );
case -1:
- log_error("fork of '%s' failed: %m\n", cmd);
+ log_error("fork of '%s' failed: %m", cmd);
err = -1;
goto out;
default:
errpipe[WRITE_END] = -1;
}
- spawn_read(event, cmd,
- outpipe[READ_END], errpipe[READ_END],
- result, ressize);
+ spawn_read(event,
+ timeout_usec,
+ cmd,
+ outpipe[READ_END], errpipe[READ_END],
+ result, ressize);
- err = spawn_wait(event, cmd, pid);
+ err = spawn_wait(event, timeout_usec, cmd, pid);
}
out:
return err;
}
-static int rename_netif(struct udev_event *event)
-{
+static int rename_netif(struct udev_event *event) {
struct udev_device *dev = event->dev;
- int sk;
- struct ifreq ifr;
- int err;
+ _cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL;
+ char name[IFNAMSIZ];
+ const char *oldname;
+ int r;
- log_debug("changing net interface name from '%s' to '%s'\n",
- udev_device_get_sysname(dev), event->name);
+ oldname = udev_device_get_sysname(dev);
- sk = socket(PF_INET, SOCK_DGRAM, 0);
- if (sk < 0) {
- err = -errno;
- log_error("error opening socket: %m\n");
- return err;
- }
+ log_debug("changing net interface name from '%s' to '%s'",
+ oldname, event->name);
- memset(&ifr, 0x00, sizeof(struct ifreq));
- strscpy(ifr.ifr_name, IFNAMSIZ, udev_device_get_sysname(dev));
- strscpy(ifr.ifr_newname, IFNAMSIZ, event->name);
- err = ioctl(sk, SIOCSIFNAME, &ifr);
- if (err >= 0) {
- print_kmsg("renamed network interface %s to %s\n", ifr.ifr_name, ifr.ifr_newname);
- } else {
- err = -errno;
- log_error("error changing net interface name %s to %s: %m\n", ifr.ifr_name, ifr.ifr_newname);
- }
- close(sk);
- return err;
+ strscpy(name, IFNAMSIZ, event->name);
+
+ r = sd_rtnl_open(&rtnl, 0);
+ if (r < 0)
+ return r;
+
+ r = rtnl_set_link_name(rtnl, udev_device_get_ifindex(dev), name);
+ if (r < 0)
+ log_error("error changing net interface name %s to %s: %s",
+ oldname, name, strerror(-r));
+ else
+ print_kmsg("renamed network interface %s to %s\n", oldname, name);
+
+ return r;
}
-int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules, const sigset_t *sigmask)
-{
+void udev_event_execute_rules(struct udev_event *event,
+ usec_t timeout_usec,
+ struct udev_rules *rules, const sigset_t *sigmask) {
struct udev_device *dev = event->dev;
- int err = 0;
if (udev_device_get_subsystem(dev) == NULL)
- return -1;
+ return;
- if (strcmp(udev_device_get_action(dev), "remove") == 0) {
+ if (streq(udev_device_get_action(dev), "remove")) {
udev_device_read_db(dev, NULL);
udev_device_delete_db(dev);
udev_device_tag_index(dev, NULL, false);
if (major(udev_device_get_devnum(dev)) != 0)
udev_watch_end(event->udev, dev);
- udev_rules_apply_to_event(rules, event, sigmask);
+ udev_rules_apply_to_event(rules, event, timeout_usec, sigmask);
if (major(udev_device_get_devnum(dev)) != 0)
udev_node_remove(dev);
udev_watch_end(event->udev, event->dev_db);
}
- udev_rules_apply_to_event(rules, event, sigmask);
+ udev_rules_apply_to_event(rules, event, timeout_usec, sigmask);
/* rename a new network interface, if needed */
- if (udev_device_get_ifindex(dev) > 0 && strcmp(udev_device_get_action(dev), "add") == 0 &&
- event->name != NULL && strcmp(event->name, udev_device_get_sysname(dev)) != 0) {
+ if (udev_device_get_ifindex(dev) > 0 && streq(udev_device_get_action(dev), "add") &&
+ event->name != NULL && !streq(event->name, udev_device_get_sysname(dev))) {
char syspath[UTIL_PATH_SIZE];
char *pos;
+ int r;
- err = rename_netif(event);
- if (err == 0) {
- log_debug("renamed netif to '%s'\n", event->name);
+ r = rename_netif(event);
+ if (r >= 0) {
+ log_debug("renamed netif to '%s'", event->name);
/* remember old name */
udev_device_add_property(dev, "INTERFACE_OLD", udev_device_get_sysname(dev));
strscpy(pos, sizeof(syspath) - (pos - syspath), event->name);
udev_device_set_syspath(event->dev, syspath);
udev_device_add_property(dev, "INTERFACE", udev_device_get_sysname(dev));
- log_debug("changed devpath to '%s'\n", udev_device_get_devpath(dev));
+ log_debug("changed devpath to '%s'", udev_device_get_devpath(dev));
}
}
}
if (major(udev_device_get_devnum(dev)) > 0) {
+ bool apply;
+
/* remove/update possible left-over symlinks from old database entry */
if (event->dev_db != NULL)
udev_node_update_old_links(dev, event->dev_db);
}
}
- udev_node_add(dev, event->mode, event->uid, event->gid);
+ apply = streq(udev_device_get_action(dev), "add") || event->owner_set || event->group_set || event->mode_set;
+ udev_node_add(dev, apply, event->mode, event->uid, event->gid, &event->seclabel_list);
}
/* preserve old, or get new initialization timestamp */
udev_device_unref(event->dev_db);
event->dev_db = NULL;
}
- return err;
}
-void udev_event_execute_run(struct udev_event *event, const sigset_t *sigmask)
-{
+void udev_event_execute_run(struct udev_event *event, usec_t timeout_usec, const sigset_t *sigmask) {
struct udev_list_entry *list_entry;
udev_list_entry_foreach(list_entry, udev_list_get_entry(&event->run_list)) {
char **envp;
if (event->exec_delay > 0) {
- log_debug("delay execution of '%s'\n", program);
+ log_debug("delay execution of '%s'", program);
sleep(event->exec_delay);
}
udev_event_apply_format(event, cmd, program, sizeof(program));
envp = udev_device_get_properties_envp(event->dev);
- udev_event_spawn(event, program, envp, sigmask, NULL, 0);
+ udev_event_spawn(event, timeout_usec, program, envp, sigmask, NULL, 0);
}
}
}