bus: support entering containers without specifying the type

[thirdparty/systemd.git] / src / shared / dbus-loop.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  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 <stdbool.h>
#include <assert.h>
#include <sys/epoll.h>
#include <string.h>
#include <errno.h>
#include <sys/timerfd.h>
#include <unistd.h>

#include "dbus-loop.h"
#include "dbus-common.h"
#include "util.h"

/* Minimal implementation of the dbus loop which integrates all dbus
 * events into a single epoll fd which we can triviall integrate with
 * other loops. Note that this is not used in the main systemd daemon
 * since we run a more elaborate mainloop there. */

typedef struct EpollData {
        int fd;
        void *object;
        bool is_timeout:1;
        bool fd_is_dupped:1;
} EpollData;

static dbus_bool_t add_watch(DBusWatch *watch, void *data) {
        _cleanup_free_ EpollData *e = NULL;
        struct epoll_event ev = {};

        assert(watch);

        e = new0(EpollData, 1);
        if (!e)
                return FALSE;

        e->fd = dbus_watch_get_unix_fd(watch);
        e->object = watch;
        e->is_timeout = false;

        ev.events = bus_flags_to_events(watch);
        ev.data.ptr = e;

        if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0) {

                if (errno != EEXIST)
                        return FALSE;

                /* Hmm, bloody D-Bus creates multiple watches on the
                 * same fd. epoll() does not like that. As a dirty
                 * hack we simply dup() the fd and hence get a second
                 * one we can safely add to the epoll(). */

                e->fd = dup(e->fd);
                if (e->fd < 0)
                        return FALSE;

                if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0) {
                        close_nointr_nofail(e->fd);
                        return FALSE;
                }

                e->fd_is_dupped = true;
        }

        dbus_watch_set_data(watch, e, NULL);
        e = NULL; /* prevent freeing */

        return TRUE;
}

static void remove_watch(DBusWatch *watch, void *data) {
        _cleanup_free_ EpollData *e = NULL;

        assert(watch);

        e = dbus_watch_get_data(watch);
        if (!e)
                return;

        assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0);

        if (e->fd_is_dupped)
                close_nointr_nofail(e->fd);
}

static void toggle_watch(DBusWatch *watch, void *data) {
        EpollData *e;
        struct epoll_event ev = {};

        assert(watch);

        e = dbus_watch_get_data(watch);
        if (!e)
                return;

        ev.data.ptr = e;
        ev.events = bus_flags_to_events(watch);

        assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_MOD, e->fd, &ev) == 0);
}

static int timeout_arm(EpollData *e) {
        struct itimerspec its = {};

        assert(e);
        assert(e->is_timeout);

        if (dbus_timeout_get_enabled(e->object)) {
                timespec_store(&its.it_value, dbus_timeout_get_interval(e->object) * USEC_PER_MSEC);
                its.it_interval = its.it_value;
        }

        if (timerfd_settime(e->fd, 0, &its, NULL) < 0)
                return -errno;

        return 0;
}

static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) {
        EpollData *e;
        struct epoll_event ev = {};

        assert(timeout);

        e = new0(EpollData, 1);
        if (!e)
                return FALSE;

        e->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
        if (e->fd < 0)
                goto fail;

        e->object = timeout;
        e->is_timeout = true;

        if (timeout_arm(e) < 0)
                goto fail;

        ev.events = EPOLLIN;
        ev.data.ptr = e;

        if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0)
                goto fail;

        dbus_timeout_set_data(timeout, e, NULL);

        return TRUE;

fail:
        if (e->fd >= 0)
                close_nointr_nofail(e->fd);

        free(e);
        return FALSE;
}

static void remove_timeout(DBusTimeout *timeout, void *data) {
        _cleanup_free_ EpollData *e = NULL;

        assert(timeout);

        e = dbus_timeout_get_data(timeout);
        if (!e)
                return;

        assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0);
        close_nointr_nofail(e->fd);
}

static void toggle_timeout(DBusTimeout *timeout, void *data) {
        EpollData *e;
        int r;

        assert(timeout);

        e = dbus_timeout_get_data(timeout);
        if (!e)
                return;

        r = timeout_arm(e);
        if (r < 0)
                log_error("Failed to rearm timer: %s", strerror(-r));
}

int bus_loop_open(DBusConnection *c) {
        int fd;

        assert(c);

        fd = epoll_create1(EPOLL_CLOEXEC);
        if (fd < 0)
                return -errno;

        if (!dbus_connection_set_watch_functions(c, add_watch, remove_watch, toggle_watch, INT_TO_PTR(fd), NULL) ||
            !dbus_connection_set_timeout_functions(c, add_timeout, remove_timeout, toggle_timeout, INT_TO_PTR(fd), NULL)) {
                close_nointr_nofail(fd);
                return -ENOMEM;
        }

        return fd;
}

int bus_loop_dispatch(int fd) {
        int n;
        struct epoll_event event = {};
        EpollData *d;

        assert(fd >= 0);

        n = epoll_wait(fd, &event, 1, 0);
        if (n < 0)
                return errno == EAGAIN || errno == EINTR ? 0 : -errno;

        assert_se(d = event.data.ptr);

        if (d->is_timeout) {
                DBusTimeout *t = d->object;

                if (dbus_timeout_get_enabled(t))
                        dbus_timeout_handle(t);
        } else {
                DBusWatch *w = d->object;

                if (dbus_watch_get_enabled(w))
                        dbus_watch_handle(w, bus_events_to_flags(event.events));
        }

        return 0;
}