shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2025-01-03 01:17:45 +03:00
Code

add basic (and not very useful) D-Bus support

Browse Source
This commit is contained in:
Lennart Poettering 2010-02-01 03:33:24 +01:00
parent b9f880f4f4
commit ea4309869e
18 changed files with 1392 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Makefile
View File

@ -1,5 +1,5 @@
CFLAGS=-Wall -Wextra -O0 -g -pipe -D_GNU_SOURCE -fdiagnostics-show-option -Wno-unused-parameter -DUNIT_PATH=\"/tmp/does/not/exist\" `pkg-config --cflags libudev`
LIBS=-lrt -lcap `pkg-config --libs libudev`
CFLAGS=-Wall -Wextra -O0 -g -pipe -D_GNU_SOURCE -fdiagnostics-show-option -Wno-unused-parameter -DUNIT_PATH=\"/tmp/does/not/exist\" `pkg-config --cflags libudev dbus-1`
LIBS=-lrt -lcap `pkg-config --libs libudev dbus-1`
COMMON= \
unit.o \
@ -23,7 +23,11 @@ COMMON= \
timer.o \
load-dropin.o \
execute.o \
ratelimit.o
ratelimit.o \
dbus.o \
dbus-manager.o \
dbus-unit.o \
dbus-job.o
all: systemd test-engine test-job-type systemd-logger

4
conf-parser.h
View File

@ -8,12 +8,12 @@
/* An abstract parser for simple, line based, shallow configuration
* files consisting of variable assignments only. */
typedef int (*config_parser_cb_t)(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata);
typedef int (*ConfigParserCallback)(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata);
/* Wraps info for parsing a specific configuration variable */
typedef struct ConfigItem {
const char *lvalue; /* name of the variable */
config_parser_cb_t parse; /* Function that is called to parse the variable's value */
ConfigParserCallback parse; /* Function that is called to parse the variable's value */
void *data; /* Where to store the variable's data */
const char *section;
} ConfigItem;

32
dbus-job.c Normal file
View File

@ -0,0 +1,32 @@
/*-*- Mode: C; c-basic-offset: 8 -*-*/
#include "dbus.h"
#include "log.h"
static const char introspection[] =
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
"<node>"
" <interface name=\"org.freedesktop.systemd1.Job\">"
" </interface>"
BUS_PROPERTIES_INTERFACE
BUS_INTROSPECTABLE_INTERFACE
"</node>";
DBusHandlerResult bus_job_message_handler(DBusConnection *connection, DBusMessage *message, void *data) {
Manager *m = data;
assert(connection);
assert(message);
assert(m);
log_debug("Got D-Bus request: %s.%s() on %s",
dbus_message_get_interface(message),
dbus_message_get_member(message),
dbus_message_get_path(message));
return bus_default_message_handler(m, message, introspection, NULL);
}
const DBusObjectPathVTable bus_job_vtable = {
.message_function = bus_job_message_handler
};

359
dbus-manager.c Normal file
View File

@ -0,0 +1,359 @@
/*-*- Mode: C; c-basic-offset: 8 -*-*/
#include <errno.h>
#include "dbus.h"
#include "log.h"
#define INTROSPECTION_BEGIN \
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
"<node>" \
" <interface name=\"org.freedesktop.systemd1\">" \
" <method name=\"GetUnit\">" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>" \
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>" \
" </method>" \
" <method name=\"LoadUnit\">" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>" \
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>" \
" </method>" \
" <method name=\"GetJob\">" \
" <arg name=\"id\" type=\"u\" direction=\"in\"/>" \
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>" \
" </method>" \
" <method name=\"ClearJobs\"/>" \
" <method name=\"ListUnits\">" \
" <arg name=\"units\" type=\"a(ssssouso)\" direction=\"out\"/>" \
" </method>" \
" <method name=\"ListJobs\">" \
" <arg name=\"jobs\" type=\"a(usssoo)\" direction=\"out\"/>" \
" </method>" \
" </interface>" \
BUS_PROPERTIES_INTERFACE \
BUS_INTROSPECTABLE_INTERFACE
#define INTROSPECTION_END \
"</node>"
DBusHandlerResult bus_manager_message_handler(DBusConnection *connection, DBusMessage *message, void *data) {
int r;
Manager *m = data;
DBusError error;
DBusMessage *reply = NULL;
char * path = NULL;
assert(connection);
assert(message);
assert(m);
dbus_error_init(&error);
log_debug("Got D-Bus request: %s.%s() on %s",
dbus_message_get_interface(message),
dbus_message_get_member(message),
dbus_message_get_path(message));
if (dbus_message_is_method_call(message, "org.freedesktop.systemd1", "GetUnit")) {
const char *name;
Unit *u;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
return bus_send_error_reply(m, message, &error, -EINVAL);
if (!(u = manager_get_unit(m, name)))
return bus_send_error_reply(m, message, NULL, -ENOENT);
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
if (!(path = unit_dbus_path(u)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1", "LoadUnit")) {
const char *name;
Unit *u;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
return bus_send_error_reply(m, message, &error, -EINVAL);
if ((r = manager_load_unit(m, name, &u)) < 0)
return bus_send_error_reply(m, message, NULL, r);
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
if (!(path = unit_dbus_path(u)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1", "GetJob")) {
uint32_t id;
Job *j;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_UINT32, &id,
DBUS_TYPE_INVALID))
return bus_send_error_reply(m, message, &error, -EINVAL);
if (!(j = manager_get_job(m, id)))
return bus_send_error_reply(m, message, NULL, -ENOENT);
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
if (!(path = job_dbus_path(j)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1", "ClearJobs")) {
manager_clear_jobs(m);
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1", "ListUnits")) {
DBusMessageIter iter, sub;
Iterator i;
Unit *u;
const char *k;
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssouso)", &sub))
goto oom;
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
char *unit_path, *job_path;
const char *id, *description, *load_state, *active_state, *job_type;
DBusMessageIter sub2;
uint32_t job_id;
id = unit_id(u);
if (k != id)
continue;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
goto oom;
description = unit_description(u);
load_state = unit_load_state_to_string(u->meta.load_state);
active_state = unit_active_state_to_string(unit_active_state(u));
if (!(unit_path = unit_dbus_path(u)))
goto oom;
if (u->meta.job) {
job_id = (uint32_t) u->meta.job->id;
if (!(job_path = job_dbus_path(u->meta.job))) {
free(unit_path);
goto oom;
}
job_type = job_type_to_string(u->meta.job->state);
} else {
job_id = 0;
job_path = unit_path;
job_type = "";
}
if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &id) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &description) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &load_state) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &active_state) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &job_id) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &job_type) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path)) {
free(unit_path);
if (u->meta.job)
free(job_path);
goto oom;
}
free(unit_path);
if (u->meta.job)
free(job_path);
if (!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1", "ListJobs")) {
DBusMessageIter iter, sub;
Iterator i;
Job *j;
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(usssoo)", &sub))
goto oom;
HASHMAP_FOREACH(j, m->jobs, i) {
char *unit_path, *job_path;
const char *unit, *state, *type;
uint32_t id;
DBusMessageIter sub2;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
goto oom;
id = (uint32_t) j->id;
unit = unit_id(j->unit);
state = job_state_to_string(j->state);
type = job_type_to_string(j->state);
if (!(job_path = job_dbus_path(j)))
goto oom;
if (!(unit_path = unit_dbus_path(j->unit))) {
free(job_path);
goto oom;
}
if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &id) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &unit) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &type) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &state) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path)) {
free(job_path);
free(unit_path);
goto oom;
}
free(job_path);
free(unit_path);
if (!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
char *introspection = NULL;
FILE *f;
Iterator i;
Unit *u;
Job *j;
const char *k;
size_t size;
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
/* We roll our own introspection code here, instead of
* relying on bus_default_message_handler() because we
* need to generate our introspection string
* dynamically. */
if (!(f = open_memstream(&introspection, &size)))
goto oom;
fputs(INTROSPECTION_BEGIN, f);
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
char *p;
if (k != unit_id(u))
continue;
if (!(p = bus_path_escape(k))) {
fclose(f);
free(introspection);
goto oom;
}
fprintf(f, "<node name=\"unit/%s\"/>", p);
free(p);
}
HASHMAP_FOREACH(j, m->jobs, i)
fprintf(f, "<node name=\"job/%lu\"/>", (unsigned long) j->id);
fputs(INTROSPECTION_END, f);
if (ferror(f)) {
fclose(f);
free(introspection);
goto oom;
}
fclose(f);
if (!introspection)
goto oom;
if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
free(introspection);
goto oom;
}
free(introspection);
} else
return bus_default_message_handler(m, message, NULL, NULL);
free(path);
if (reply) {
if (!dbus_connection_send(connection, reply, NULL))
goto oom;
dbus_message_unref(reply);
}
return DBUS_HANDLER_RESULT_HANDLED;
oom:
free(path);
if (reply)
dbus_message_unref(reply);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
const DBusObjectPathVTable bus_manager_vtable = {
.message_function = bus_manager_message_handler
};

133
dbus-unit.c Normal file
View File

@ -0,0 +1,133 @@
/*-*- Mode: C; c-basic-offset: 8 -*-*/
#include <errno.h>
#include "dbus.h"
#include "log.h"
static const char introspection[] =
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
"<node>"
" <!-- you suck -->"
" <interface name=\"org.freedesktop.systemd1.Unit\">"
" <property name=\"Id\" type=\"s\" access=\"read\"/>"
" <property name=\"Description\" type=\"s\" access=\"read\"/>"
" <property name=\"LoadState\" type=\"s\" access=\"read\"/>"
" <property name=\"ActiveState\" type=\"s\" access=\"read\"/>"
" </interface>"
BUS_PROPERTIES_INTERFACE
BUS_INTROSPECTABLE_INTERFACE
"</node>";
static int bus_unit_append_id(Manager *m, DBusMessageIter *i, const char *property, void *data) {
Unit *u = data;
const char *id;
assert(m);
assert(i);
assert(property);
assert(u);
id = unit_id(u);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &u))
return -ENOMEM;
return 0;
}
static int bus_unit_append_description(Manager *m, DBusMessageIter *i, const char *property, void *data) {
Unit *u = data;
const char *d;
assert(m);
assert(i);
assert(property);
assert(u);
d = unit_description(u);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &d))
return -ENOMEM;
return 0;
}
static int bus_unit_append_load_state(Manager *m, DBusMessageIter *i, const char *property, void *data) {
Unit *u = data;
const char *state;
assert(m);
assert(i);
assert(property);
assert(u);
state = unit_load_state_to_string(u->meta.load_state);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
return -ENOMEM;
return 0;
}
static int bus_unit_append_active_state(Manager *m, DBusMessageIter *i, const char *property, void *data) {
Unit *u = data;
const char *state;
assert(m);
assert(i);
assert(property);
assert(u);
state = unit_active_state_to_string(unit_active_state(u));
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
return -ENOMEM;
return 0;
}
static DBusHandlerResult bus_unit_message_dispatch(Unit *u, DBusMessage *message) {
const BusProperty properties[] = {
{ "org.freedesktop.systemd1.Unit", "Id", bus_unit_append_id, "s", u },
{ "org.freedesktop.systemd1.Unit", "Description", bus_unit_append_description, "s", u },
{ "org.freedesktop.systemd1.Unit", "LoadState", bus_unit_append_load_state, "s", u },
{ "org.freedesktop.systemd1.Unit", "ActiveState", bus_unit_append_active_state, "s", u },
{ NULL, NULL, NULL, NULL, NULL }
};
return bus_default_message_handler(u->meta.manager, message, introspection, properties);
}
static DBusHandlerResult bus_unit_message_handler(DBusConnection *connection, DBusMessage *message, void *data) {
Manager *m = data;
Unit *u;
int r;
assert(connection);
assert(message);
assert(m);
log_debug("Got D-Bus request: %s.%s() on %s",
dbus_message_get_interface(message),
dbus_message_get_member(message),
dbus_message_get_path(message));
if ((r = manager_get_unit_from_dbus_path(m, dbus_message_get_path(message), &u)) < 0) {
if (r == -ENOMEM)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if (r == -ENOENT)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
return bus_send_error_reply(m, message, NULL, r);
}
return bus_unit_message_dispatch(u, message);
}
const DBusObjectPathVTable bus_unit_vtable = {
.message_function = bus_unit_message_handler
};

608
dbus.c Normal file
View File

@ -0,0 +1,608 @@
/*-*- Mode: C; c-basic-offset: 8 -*-*/
#include <dbus/dbus.h>
#include <sys/epoll.h>
#include <sys/timerfd.h>
#include <errno.h>
#include <unistd.h>
#include "dbus.h"
#include "log.h"
#include "strv.h"
static void bus_dispatch_status(DBusConnection *bus, DBusDispatchStatus status, void *data) {
Manager *m = data;
assert(bus);
assert(m);
m->request_bus_dispatch = status != DBUS_DISPATCH_COMPLETE;
}
static uint32_t bus_flags_to_events(DBusWatch *bus_watch) {
unsigned flags;
uint32_t events = 0;
assert(bus_watch);
/* no watch flags for disabled watches */
if (!dbus_watch_get_enabled(bus_watch))
return 0;
flags = dbus_watch_get_flags(bus_watch);
if (flags & DBUS_WATCH_READABLE)
events |= EPOLLIN;
if (flags & DBUS_WATCH_WRITABLE)
events |= EPOLLOUT;
return events | EPOLLHUP | EPOLLERR;
}
static unsigned events_to_bus_flags(uint32_t events) {
unsigned flags = 0;
if (events & EPOLLIN)
flags |= DBUS_WATCH_READABLE;
if (events & EPOLLOUT)
flags |= DBUS_WATCH_WRITABLE;
if (events & EPOLLHUP)
flags |= DBUS_WATCH_HANGUP;
if (events & EPOLLERR)
flags |= DBUS_WATCH_ERROR;
return flags;
}
void bus_watch_event(Manager *m, Watch *w, int events) {
assert(m);
assert(w);
/* This is called by the event loop whenever there is
* something happening on D-Bus' file handles. */
if (!(dbus_watch_get_enabled(w->data.bus_watch)))
return;
dbus_watch_handle(w->data.bus_watch, events_to_bus_flags(events));
}
static dbus_bool_t bus_add_watch(DBusWatch *bus_watch, void *data) {
Manager *m = data;
Watch *w;
struct epoll_event ev;
assert(bus_watch);
assert(m);
if (!(w = new0(Watch, 1)))
return FALSE;
w->fd = dbus_watch_get_unix_fd(bus_watch);
w->type = WATCH_DBUS_WATCH;
w->data.bus_watch = bus_watch;
zero(ev);
ev.events = bus_flags_to_events(bus_watch);
ev.data.ptr = w;
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0) {
if (errno != EEXIST) {
free(w);
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(). */
if ((w->fd = dup(w->fd)) < 0) {
free(w);
return FALSE;
}
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0) {
free(w);
close_nointr_nofail(w->fd);
return FALSE;
}
w->fd_is_dupped = true;
}
dbus_watch_set_data(bus_watch, w, NULL);
return TRUE;
}
static void bus_remove_watch(DBusWatch *bus_watch, void *data) {
Manager *m = data;
Watch *w;
assert(bus_watch);
assert(m);
if (!(w = dbus_watch_get_data(bus_watch)))
return;
assert(w->type == WATCH_DBUS_WATCH);
assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
if (w->fd_is_dupped)
close_nointr_nofail(w->fd);
free(w);
}
static void bus_toggle_watch(DBusWatch *bus_watch, void *data) {
Manager *m = data;
Watch *w;
struct epoll_event ev;
assert(bus_watch);
assert(m);
assert_se(w = dbus_watch_get_data(bus_watch));
assert(w->type == WATCH_DBUS_WATCH);
zero(ev);
ev.events = bus_flags_to_events(bus_watch);
ev.data.ptr = w;
assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_MOD, w->fd, &ev) == 0);
}
static int bus_timeout_arm(Manager *m, Watch *w) {
struct itimerspec its;
assert(m);
assert(w);
zero(its);
if (dbus_timeout_get_enabled(w->data.bus_timeout)) {
timespec_store(&its.it_value, dbus_timeout_get_interval(w->data.bus_timeout) * USEC_PER_MSEC);
its.it_interval = its.it_interval;
}
if (timerfd_settime(w->fd, 0, &its, NULL) < 0)
return -errno;
return 0;
}
void bus_timeout_event(Manager *m, Watch *w, int events) {
assert(m);
assert(w);
/* This is called by the event loop whenever there is
* something happening on D-Bus' file handles. */
if (!(dbus_timeout_get_enabled(w->data.bus_timeout)))
return;
dbus_timeout_handle(w->data.bus_timeout);
}
static dbus_bool_t bus_add_timeout(DBusTimeout *timeout, void *data) {
Manager *m = data;
Watch *w;
struct epoll_event ev;
assert(timeout);
assert(m);
if (!(w = new0(Watch, 1)))
return FALSE;
if (!(w->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
goto fail;
w->type = WATCH_DBUS_TIMEOUT;
w->data.bus_timeout = timeout;
if (bus_timeout_arm(m, w) < 0)
goto fail;
zero(ev);
ev.events = EPOLLIN;
ev.data.ptr = w;
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, w->fd, &ev) < 0)
goto fail;
dbus_timeout_set_data(timeout, w, NULL);
return TRUE;
fail:
if (w->fd >= 0)
close_nointr_nofail(w->fd);
free(w);
return FALSE;
}
static void bus_remove_timeout(DBusTimeout *timeout, void *data) {
Manager *m = data;
Watch *w;
assert(timeout);
assert(m);
if (!(w = dbus_timeout_get_data(timeout)))
return;
assert(w->type == WATCH_DBUS_TIMEOUT);
assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
close_nointr_nofail(w->fd);
free(w);
}
static void bus_toggle_timeout(DBusTimeout *timeout, void *data) {
Manager *m = data;
Watch *w;
int r;
assert(timeout);
assert(m);
assert_se(w = dbus_timeout_get_data(timeout));
assert(w->type == WATCH_DBUS_TIMEOUT);
if ((r = bus_timeout_arm(m, w)) < 0)
log_error("Failed to rearm timer: %s", strerror(-r));
}
void bus_dispatch(Manager *m) {
assert(m);
if (dbus_connection_dispatch(m->bus) == DBUS_DISPATCH_COMPLETE)
m->request_bus_dispatch = false;
}
static int request_name(Manager *m) {
DBusMessage *message;
const char *name = "org.freedesktop.systemd1";
uint32_t flags = 0;
if (!(message = dbus_message_new_method_call(
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"RequestName")))
return -ENOMEM;
if (!dbus_message_append_args(
message,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_UINT32, &flags,
DBUS_TYPE_INVALID)) {
dbus_message_unref(message);
return -ENOMEM;
}
if (!dbus_connection_send(m->bus, message, NULL)) {
dbus_message_unref(message);
return -ENOMEM;
}
/* We simple ask for the name and don't wait for it. Sooner or
* later we'll have it, and we wouldn't know what to do on
* error anyway. */
dbus_message_unref(message);
return 0;
}
int bus_init(Manager *m) {
DBusError error;
char *id;
int r;
assert(m);
if (m->bus)
return 0;
dbus_connection_set_change_sigpipe(FALSE);
dbus_error_init(&error);
if (!(m->bus = dbus_bus_get_private(m->is_init ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &error))) {
log_error("Failed to get D-Bus connection: %s", error.message);
dbus_error_free(&error);
return -ECONNREFUSED;
}
dbus_connection_set_exit_on_disconnect(m->bus, FALSE);
dbus_connection_set_dispatch_status_function(m->bus, bus_dispatch_status, m, NULL);
if (!dbus_connection_set_watch_functions(m->bus, bus_add_watch, bus_remove_watch, bus_toggle_watch, m, NULL) ||
!dbus_connection_set_timeout_functions(m->bus, bus_add_timeout, bus_remove_timeout, bus_toggle_timeout, m, NULL) ||
!dbus_connection_register_object_path(m->bus, "/org/freedesktop/systemd1", &bus_manager_vtable, m) ||
!dbus_connection_register_fallback(m->bus, "/org/freedesktop/systemd1/unit", &bus_unit_vtable, m) ||
!dbus_connection_register_fallback(m->bus, "/org/freedesktop/systemd1/job", &bus_job_vtable, m)) {
bus_done(m);
return -ENOMEM;
}
if ((r = request_name(m)) < 0) {
bus_done(m);
return r;
}
log_debug("Successfully connected to D-Bus bus %s as %s",
strnull((id = dbus_connection_get_server_id(m->bus))),
strnull(dbus_bus_get_unique_name(m->bus)));
dbus_free(id);
m->request_bus_dispatch = true;
return 0;
}
void bus_done(Manager *m) {
assert(m);
if (m->bus) {
dbus_connection_close(m->bus);
dbus_connection_unref(m->bus);
m->bus = NULL;
}
}
DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, const char*introspection, const BusProperty *properties) {
DBusError error;
DBusMessage *reply = NULL;
int r;
assert(m);
assert(message);
dbus_error_init(&error);
if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect") && introspection) {
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "Get") && properties) {
const char *interface, *property;
const BusProperty *p;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &property,
DBUS_TYPE_INVALID))
return bus_send_error_reply(m, message, &error, -EINVAL);
for (p = properties; p->property; p++)
if (streq(p->interface, interface) && streq(p->property, property))
break;
if (p->property) {
DBusMessageIter iter, sub;
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, p->signature, &sub))
goto oom;
if ((r = p->append(m, &sub, property, p->data)) < 0) {
if (r == -ENOMEM)
goto oom;
dbus_message_unref(reply);
return bus_send_error_reply(m, message, NULL, r);
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
}
} else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "GetAll") && properties) {
const char *interface;
const BusProperty *p;
DBusMessageIter iter, sub, sub2, sub3;
bool any = false;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_INVALID))
return bus_send_error_reply(m, message, &error, -EINVAL);
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub))
goto oom;
for (p = properties; p->property; p++) {
if (!streq(p->interface, interface))
continue;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, "sv" , &sub2) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &p->property) ||
!dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, p->signature, &sub3))
goto oom;
if ((r = p->append(m, &sub3, p->property, p->data)) < 0) {
if (r == -ENOMEM)
goto oom;
dbus_message_unref(reply);
return bus_send_error_reply(m, message, NULL, r);
}
if (!dbus_message_iter_close_container(&sub2, &sub3) ||
!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
any = true;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
}
if (reply) {
if (!dbus_connection_send(m->bus, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
oom:
if (reply)
dbus_message_unref(reply);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
static const char *error_to_dbus(int error) {
switch(error) {
case -EINVAL:
return DBUS_ERROR_INVALID_ARGS;
case -ENOMEM:
return DBUS_ERROR_NO_MEMORY;
case -EPERM:
case -EACCES:
return DBUS_ERROR_ACCESS_DENIED;
case -ESRCH:
return DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN;
case -ENOENT:
return DBUS_ERROR_FILE_NOT_FOUND;
case -EEXIST:
return DBUS_ERROR_FILE_EXISTS;
case -ETIMEDOUT:
return DBUS_ERROR_TIMEOUT;
case -EIO:
return DBUS_ERROR_IO_ERROR;
case -ENETRESET:
case -ECONNABORTED:
case -ECONNRESET:
return DBUS_ERROR_DISCONNECTED;
}
return DBUS_ERROR_FAILED;
}
DBusHandlerResult bus_send_error_reply(Manager *m, DBusMessage *message, DBusError *bus_error, int error) {
DBusMessage *reply = NULL;
const char *name, *text;
if (bus_error && dbus_error_is_set(bus_error)) {
name = bus_error->name;
text = bus_error->message;
} else {
name = error_to_dbus(error);
text = strerror(-error);
}
if (!(reply = dbus_message_new_error(message, name, text)))
goto oom;
if (!dbus_connection_send(m->bus, reply, NULL))
goto oom;
dbus_message_unref(reply);
if (bus_error)
dbus_error_free(bus_error);
return DBUS_HANDLER_RESULT_HANDLED;
oom:
if (reply)
dbus_message_unref(reply);
if (bus_error)
dbus_error_free(bus_error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
int bus_property_append_string(Manager *m, DBusMessageIter *i, const char *property, void *data) {
const char *t = data;
assert(m);
assert(i);
assert(property);
assert(t);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t))
return -ENOMEM;
return 0;
}
int bus_property_append_strv(Manager *m, DBusMessageIter *i, const char *property, void *data) {
DBusMessageIter sub;
char **t = data;
assert(m);
assert(i);
assert(property);
if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "s", &sub))
return -ENOMEM;
STRV_FOREACH(t, t)
if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t))
return -ENOMEM;
if (!dbus_message_iter_close_container(i, &sub))
return -ENOMEM;
return 0;
}
int bus_property_append_bool(Manager *m, DBusMessageIter *i, const char *property, void *data) {
bool *b = data;
dbus_bool_t db;
assert(m);
assert(i);
assert(property);
assert(b);
db = *b;
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &db))
return -ENOMEM;
return 0;
}

60
dbus.h Normal file
View File

@ -0,0 +1,60 @@
/*-*- Mode: C; c-basic-offset: 8 -*-*/
#ifndef foodbushfoo
#define foodbushfoo
#include <dbus/dbus.h>
#include "manager.h"
typedef int (*BusPropertyCallback)(Manager *m, DBusMessageIter *iter, const char *property, void *data);
typedef struct BusProperty {
const char *interface; /* interface of the property */
const char *property; /* name of the property */
BusPropertyCallback append; /* Function that is called to serialize this property */
const char *signature;
void *data; /* The data of this property */
} BusProperty;
#define BUS_PROPERTIES_INTERFACE \
" <interface name=\"org.freedesktop.DBus.Properties\">" \
" <method name=\"Get\">" \
" <arg name=\"interface\" direction=\"in\" type=\"s\"/>" \
" <arg name=\"property\" direction=\"in\" type=\"s\"/>" \
" <arg name=\"value\" direction=\"out\" type=\"v\"/>" \
" </method>" \
" <method name=\"GetAll\">" \
" <arg name=\"interface\" direction=\"in\" type=\"s\"/>" \
" <arg name=\"properties\" direction=\"out\" type=\"a{sv}\"/>" \
" </method>" \
" </interface>"
#define BUS_INTROSPECTABLE_INTERFACE \
" <interface name=\"org.freedesktop.DBus.Introspectable\">" \
" <method name=\"Introspect\">" \
" <arg name=\"data\" type=\"s\" direction=\"out\"/>" \
" </method>" \
" </interface>"
int bus_init(Manager *m);
void bus_done(Manager *m);
void bus_dispatch(Manager *m);
void bus_watch_event(Manager *m, Watch *w, int events);
void bus_timeout_event(Manager *m, Watch *w, int events);
DBusHandlerResult bus_default_message_handler(Manager *m, DBusMessage *message, const char* introspection, const BusProperty *properties);
DBusHandlerResult bus_send_error_reply(Manager *m, DBusMessage *message, DBusError *bus_error, int error);
int bus_property_append_string(Manager *m, DBusMessageIter *i, const char *property, void *data);
int bus_property_append_strv(Manager *m, DBusMessageIter *i, const char *property, void *data);
int bus_property_append_bool(Manager *m, DBusMessageIter *i, const char *property, void *data);
extern const DBusObjectPathVTable bus_manager_vtable;
extern const DBusObjectPathVTable bus_job_vtable;
extern const DBusObjectPathVTable bus_unit_vtable;
#endif

2
execute.c
View File

@ -551,7 +551,7 @@ void exec_context_dump(ExecContext *c, FILE* f, const char *prefix) {
for (i = 0; i < RLIM_NLIMITS; i++)
if (c->rlimit[i])
fprintf(f, "%s: %llu\n", rlimit_to_string(i), (unsigned long long) c->rlimit[i]->rlim_max);
fprintf(f, "%s%s: %llu\n", prefix, rlimit_to_string(i), (unsigned long long) c->rlimit[i]->rlim_max);
if (c->ioprio_set)
fprintf(f,

2
execute.h
View File

@ -18,7 +18,7 @@ typedef struct ExecContext ExecContext;
#include "util.h"
/* Abstract namespace! */
#define LOGGER_SOCKET "/systemd/logger"
#define LOGGER_SOCKET "/org/freedesktop.org/systemd1/logger"
typedef enum ExecOutput {
EXEC_OUTPUT_CONSOLE,

11
job.c
View File

@ -463,6 +463,17 @@ void job_schedule_run(Job *j) {
j->in_run_queue = true;
}
char *job_dbus_path(Job *j) {
char *p;
assert(j);
if (asprintf(&p, "/org/freedesktop/systemd1/job/%lu", (unsigned long) j->id) < 0)
return NULL;
return p;
}
static const char* const job_state_table[_JOB_STATE_MAX] = {
[JOB_WAITING] = "waiting",
[JOB_RUNNING] = "running"

2
job.h
View File

@ -114,4 +114,6 @@ JobType job_type_from_string(const char *s);
const char* job_state_to_string(JobState t);
JobState job_state_from_string(const char *s);
char *job_dbus_path(Job *j);
#endif

6
main.c
View File

@ -1,5 +1,7 @@
/*-*- Mode: C; c-basic-offset: 8 -*-*/
#include <dbus/dbus.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
@ -16,7 +18,7 @@ int main(int argc, char *argv[]) {
assert_se(set_unit_path("test1") >= 0);
if (!(m = manager_new()) < 0) {
if (!(m = manager_new())) {
log_error("Failed to allocate manager object: %s", strerror(ENOMEM));
goto finish;
}
@ -55,5 +57,7 @@ finish:
log_debug("Exit.");
dbus_shutdown();
return retval;
}

58
manager.c
View File

@ -16,6 +16,7 @@
#include "strv.h"
#include "log.h"
#include "util.h"
#include "ratelimit.h"
static int manager_setup_signals(Manager *m) {
sigset_t mask;
@ -57,6 +58,7 @@ Manager* manager_new(void) {
return NULL;
m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = -1;
m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
goto fail;
@ -76,6 +78,10 @@ Manager* manager_new(void) {
if (manager_setup_signals(m) < 0)
goto fail;
/* FIXME: this should be called only when the D-Bus bus daemon is running */
if (bus_init(m) < 0)
goto fail;
return m;
fail:
@ -100,6 +106,8 @@ void manager_free(Manager *m) {
if (unit_vtable[c]->shutdown)
unit_vtable[c]->shutdown(m);
bus_done(m);
hashmap_free(m->units);
hashmap_free(m->jobs);
hashmap_free(m->transaction_jobs);
@ -1137,7 +1145,7 @@ static int process_event(Manager *m, struct epoll_event *ev, bool *quit) {
case WATCH_FD:
/* Some fd event, to be dispatched to the units */
UNIT_VTABLE(w->unit)->fd_event(w->unit, w->fd, ev->events, w);
UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
break;
case WATCH_TIMER: {
@ -1153,7 +1161,7 @@ static int process_event(Manager *m, struct epoll_event *ev, bool *quit) {
return k < 0 ? -errno : -EIO;
}
UNIT_VTABLE(w->unit)->timer_event(w->unit, v, w);
UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
break;
}
@ -1167,6 +1175,14 @@ static int process_event(Manager *m, struct epoll_event *ev, bool *quit) {
device_fd_event(m, ev->events);
break;
case WATCH_DBUS_WATCH:
bus_watch_event(m, w, ev->events);
break;
case WATCH_DBUS_TIMEOUT:
bus_timeout_event(m, w, ev->events);
break;
default:
assert_not_reached("Unknown epoll event type.");
}
@ -1178,14 +1194,27 @@ int manager_loop(Manager *m) {
int r;
bool quit = false;
RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 1000);
assert(m);
for (;;) {
struct epoll_event event;
int n;
if (!ratelimit_test(&rl)) {
/* Yay, something is going seriously wrong, pause a little */
log_warning("Looping too fast. Throttling execution a little.");
sleep(1);
}
manager_dispatch_run_queue(m);
if (m->request_bus_dispatch) {
bus_dispatch(m);
continue;
}
if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) {
if (errno == -EINTR)
@ -1203,3 +1232,28 @@ int manager_loop(Manager *m) {
return 0;
}
}
int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
char *n;
Unit *u;
assert(m);
assert(s);
assert(_u);
if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
return -EINVAL;
if (!(n = bus_path_unescape(s+31)))
return -ENOMEM;
u = manager_get_unit(m, n);
free(n);
if (!u)
return -ENOENT;
*_u = u;
return 0;
}

21
manager.h
View File

@ -7,6 +7,8 @@
#include <inttypes.h>
#include <stdio.h>
#include <dbus/dbus.h>
typedef struct Manager Manager;
typedef enum WatchType WatchType;
typedef struct Watch Watch;
@ -17,13 +19,20 @@ enum WatchType {
WATCH_FD,
WATCH_TIMER,
WATCH_MOUNT,
WATCH_UDEV
WATCH_UDEV,
WATCH_DBUS_WATCH,
WATCH_DBUS_TIMEOUT
};
struct Watch {
int fd;
WatchType type;
bool fd_is_dupped;
union {
union Unit *unit;
DBusWatch *bus_watch;
DBusTimeout *bus_timeout;
} data;
};
#include "unit.h"
@ -31,6 +40,7 @@ struct Watch {
#include "hashmap.h"
#include "list.h"
#include "set.h"
#include "dbus.h"
#define SPECIAL_DEFAULT_TARGET "default.target"
#define SPECIAL_SYSLOG_SERVICE "syslog.service"
@ -67,6 +77,10 @@ struct Manager {
bool dispatching_load_queue:1;
bool dispatching_run_queue:1;
bool is_init:1;
bool request_bus_dispatch:1;
Hashmap *watch_pids; /* pid => Unit object n:1 */
int epoll_fd;
@ -81,6 +95,9 @@ struct Manager {
/* Data specific to the mount subsystem */
FILE *proc_self_mountinfo;
Watch mount_watch;
/* Data specific to the D-Bus subsystem */
DBusConnection *bus;
};
Manager* manager_new(void);
@ -91,6 +108,8 @@ int manager_coldplug(Manager *m);
Job *manager_get_job(Manager *m, uint32_t id);
Unit *manager_get_unit(Manager *m, const char *name);
int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u);
int manager_load_unit(Manager *m, const char *path_or_name, Unit **_ret);
int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool force, Job **_ret);

36
unit.c
View File

@ -707,7 +707,7 @@ int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
assert(u);
assert(fd >= 0);
assert(w);
assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->unit == u));
assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
zero(ev);
ev.data.ptr = w;
@ -721,7 +721,7 @@ int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
w->fd = fd;
w->type = WATCH_FD;
w->unit = u;
w->data.unit = u;
return 0;
}
@ -733,12 +733,13 @@ void unit_unwatch_fd(Unit *u, Watch *w) {
if (w->type == WATCH_INVALID)
return;
assert(w->type == WATCH_FD && w->unit == u);
assert(w->type == WATCH_FD);
assert(w->data.unit == u);
assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
w->fd = -1;
w->type = WATCH_INVALID;
w->unit = NULL;
w->data.unit = NULL;
}
int unit_watch_pid(Unit *u, pid_t pid) {
@ -762,7 +763,7 @@ int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
assert(u);
assert(w);
assert(w->type == WATCH_INVALID || (w->type == WATCH_TIMER && w->unit == u));
assert(w->type == WATCH_INVALID || (w->type == WATCH_TIMER && w->data.unit == u));
/* This will try to reuse the old timer if there is one */
@ -806,13 +807,13 @@ int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
w->fd = fd;
w->type = WATCH_TIMER;
w->unit = u;
w->data.unit = u;
return 0;
fail:
if (ours)
assert_se(close_nointr(fd) == 0);
close_nointr_nofail(fd);
return -errno;
}
@ -824,14 +825,14 @@ void unit_unwatch_timer(Unit *u, Watch *w) {
if (w->type == WATCH_INVALID)
return;
assert(w->type == WATCH_TIMER && w->unit == u);
assert(w->type == WATCH_TIMER && w->data.unit == u);
assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
assert_se(close_nointr(w->fd) == 0);
w->fd = -1;
w->type = WATCH_INVALID;
w->unit = NULL;
w->data.unit = NULL;
}
bool unit_job_is_applicable(Unit *u, JobType j) {
@ -1004,6 +1005,23 @@ char *unit_name_escape_path(const char *prefix, const char *path, const char *su
return r;
}
char *unit_dbus_path(Unit *u) {
char *p, *e;
assert(u);
if (!(e = bus_path_escape(unit_id(u))))
return NULL;
if (asprintf(&p, "/org/freedesktop/systemd1/unit/%s", e) < 0) {
free(e);
return NULL;
}
free(e);
return p;
}
static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
[UNIT_SERVICE] = "service",
[UNIT_TIMER] = "timer",

2
unit.h
View File

@ -274,4 +274,6 @@ UnitActiveState unit_active_state_from_string(const char *s);
const char *unit_dependency_to_string(UnitDependency i);
UnitDependency unit_dependency_from_string(const char *s);
char *unit_dbus_path(Unit *u);
#endif

64
util.c
View File

@ -566,10 +566,10 @@ int unhexchar(char c) {
return c - '0';
if (c >= 'a' && c <= 'f')
return c - 'a';
return c - 'a' + 10;
if (c >= 'A' && c <= 'F')
return c - 'A';
return c - 'A' + 10;
return -1;
}
@ -803,6 +803,66 @@ char *xescape(const char *s, const char *bad) {
return r;
}
char *bus_path_escape(const char *s) {
assert(s);
char *r, *t;
const char *f;
/* Escapes all chars that D-Bus' object path cannot deal
* with. Can be reverse with bus_path_unescape() */
if (!(r = new(char, strlen(s)*3+1)))
return NULL;
for (f = s, t = r; *f; f++) {
if (!(*f >= 'A' && *f <= 'Z') &&
!(*f >= 'a' && *f <= 'z') &&
!(*f >= '0' && *f <= '9')) {
*(t++) = '_';
*(t++) = hexchar(*f >> 4);
*(t++) = hexchar(*f);
} else
*(t++) = *f;
}
*t = 0;
return r;
}
char *bus_path_unescape(const char *s) {
assert(s);
char *r, *t;
const char *f;
if (!(r = new(char, strlen(s)+1)))
return NULL;
for (f = s, t = r; *f; f++) {
if (*f == '_') {
int a, b;
if ((a = unhexchar(f[1])) < 0 ||
(b = unhexchar(f[2])) < 0) {
/* Invalid escape code, let's take it literal then */
*(t++) = '_';
} else {
*(t++) = (char) ((a << 4) | b);
f += 2;
}
} else
*(t++) = *f;
}
*t = 0;
return r;
}
char *path_kill_slashes(char *path) {
char *f, *t;
bool slash = false;

3
util.h
View File

@ -121,6 +121,9 @@ char *ascii_strlower(char *path);
char *xescape(const char *s, const char *bad);
char *bus_path_escape(const char *s);
char *bus_path_unescape(const char *s);
#define DEFINE_STRING_TABLE_LOOKUP(name,type) \
const char *name##_to_string(type i) { \
if (i < 0 || i >= (type) ELEMENTSOF(name##_table)) \