1ee306e124
Embedded folks don't need the machine registration stuff, hence it's nice to make this optional. Also, I'd expect that machinectl will grow additional commands quickly, for example to join existing containers and suchlike, hence it's better keeping that separate from loginctl.
360 lines
12 KiB
C
360 lines
12 KiB
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 <errno.h>
|
|
#include <string.h>
|
|
|
|
#include "machined.h"
|
|
#include "machine.h"
|
|
#include "dbus-common.h"
|
|
|
|
#define BUS_MACHINE_INTERFACE \
|
|
" <interface name=\"org.freedesktop.machine1.Machine\">\n" \
|
|
" <method name=\"Terminate\"/>\n" \
|
|
" <method name=\"Kill\">\n" \
|
|
" <arg name=\"who\" type=\"s\"/>\n" \
|
|
" <arg name=\"signal\" type=\"s\"/>\n" \
|
|
" </method>\n" \
|
|
" <property name=\"Name\" type=\"s\" access=\"read\"/>\n" \
|
|
" <property name=\"Id\" type=\"ay\" access=\"read\"/>\n" \
|
|
" <property name=\"Timestamp\" type=\"t\" access=\"read\"/>\n" \
|
|
" <property name=\"TimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
|
|
" <property name=\"Service\" type=\"s\" access=\"read\"/>\n" \
|
|
" <property name=\"Scope\" type=\"s\" access=\"read\"/>\n" \
|
|
" <property name=\"Leader\" type=\"u\" access=\"read\"/>\n" \
|
|
" <property name=\"Class\" type=\"s\" access=\"read\"/>\n" \
|
|
" <property name=\"State\" type=\"s\" access=\"read\"/>\n" \
|
|
" <property name=\"RootDirectory\" type=\"s\" access=\"read\"/>\n" \
|
|
" </interface>\n"
|
|
|
|
#define INTROSPECTION \
|
|
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
|
|
"<node>\n" \
|
|
BUS_MACHINE_INTERFACE \
|
|
BUS_PROPERTIES_INTERFACE \
|
|
BUS_PEER_INTERFACE \
|
|
BUS_INTROSPECTABLE_INTERFACE \
|
|
"</node>\n"
|
|
|
|
#define INTERFACES_LIST \
|
|
BUS_GENERIC_INTERFACES_LIST \
|
|
"org.freedesktop.machine1.Machine\0"
|
|
|
|
static int bus_machine_append_id(DBusMessageIter *i, const char *property, void *data) {
|
|
DBusMessageIter sub;
|
|
Machine *m = data;
|
|
dbus_bool_t b;
|
|
void *p;
|
|
|
|
assert(i);
|
|
assert(property);
|
|
assert(m);
|
|
|
|
if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub))
|
|
return -ENOMEM;
|
|
|
|
p = &m->id;
|
|
b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &p, 16);
|
|
if (!b)
|
|
return -ENOMEM;
|
|
|
|
if (!dbus_message_iter_close_container(i, &sub))
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int bus_machine_append_state(DBusMessageIter *i, const char *property, void *data) {
|
|
Machine *m = data;
|
|
const char *state;
|
|
|
|
assert(i);
|
|
assert(property);
|
|
assert(m);
|
|
|
|
state = machine_state_to_string(machine_get_state(m));
|
|
|
|
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int get_machine_for_path(Manager *m, const char *path, Machine **_machine) {
|
|
_cleanup_free_ char *e = NULL;
|
|
Machine *machine;
|
|
|
|
assert(m);
|
|
assert(path);
|
|
assert(_machine);
|
|
|
|
if (!startswith(path, "/org/freedesktop/machine1/machine/"))
|
|
return -EINVAL;
|
|
|
|
e = bus_path_unescape(path + 32);
|
|
if (!e)
|
|
return -ENOMEM;
|
|
|
|
machine = hashmap_get(m->machines, e);
|
|
if (!machine)
|
|
return -ENOENT;
|
|
|
|
*_machine = machine;
|
|
return 0;
|
|
}
|
|
|
|
static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_machine_append_class, machine_class, MachineClass);
|
|
|
|
static const BusProperty bus_machine_machine_properties[] = {
|
|
{ "Name", bus_property_append_string, "s", offsetof(Machine, name), true },
|
|
{ "Id", bus_machine_append_id, "ay", 0 },
|
|
{ "Timestamp", bus_property_append_usec, "t", offsetof(Machine, timestamp.realtime) },
|
|
{ "TimestampMonotonic", bus_property_append_usec, "t", offsetof(Machine, timestamp.monotonic) },
|
|
{ "Service", bus_property_append_string, "s", offsetof(Machine, service), true },
|
|
{ "Scope", bus_property_append_string, "s", offsetof(Machine, scope), true },
|
|
{ "Class", bus_machine_append_class, "s", offsetof(Machine, class) },
|
|
{ "State", bus_machine_append_state, "s", 0 },
|
|
{ "RootDirectory", bus_property_append_string, "s", offsetof(Machine, root_directory), true },
|
|
{ NULL, }
|
|
};
|
|
|
|
static DBusHandlerResult machine_message_dispatch(
|
|
Machine *m,
|
|
DBusConnection *connection,
|
|
DBusMessage *message) {
|
|
|
|
DBusError error;
|
|
_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
|
|
int r;
|
|
|
|
assert(m);
|
|
assert(connection);
|
|
assert(message);
|
|
|
|
if (dbus_message_is_method_call(message, "org.freedesktop.machine1.Machine", "Terminate")) {
|
|
|
|
r = machine_stop(m);
|
|
if (r < 0)
|
|
return bus_send_error_reply(connection, message, NULL, r);
|
|
|
|
reply = dbus_message_new_method_return(message);
|
|
if (!reply)
|
|
goto oom;
|
|
|
|
} else if (dbus_message_is_method_call(message, "org.freedesktop.machine1.Machine", "Kill")) {
|
|
const char *swho;
|
|
int32_t signo;
|
|
KillWho who;
|
|
|
|
if (!dbus_message_get_args(
|
|
message,
|
|
&error,
|
|
DBUS_TYPE_STRING, &swho,
|
|
DBUS_TYPE_INT32, &signo,
|
|
DBUS_TYPE_INVALID))
|
|
return bus_send_error_reply(connection, message, &error, -EINVAL);
|
|
|
|
if (isempty(swho))
|
|
who = KILL_ALL;
|
|
else {
|
|
who = kill_who_from_string(swho);
|
|
if (who < 0)
|
|
return bus_send_error_reply(connection, message, &error, -EINVAL);
|
|
}
|
|
|
|
if (signo <= 0 || signo >= _NSIG)
|
|
return bus_send_error_reply(connection, message, &error, -EINVAL);
|
|
|
|
r = machine_kill(m, who, signo);
|
|
if (r < 0)
|
|
return bus_send_error_reply(connection, message, NULL, r);
|
|
|
|
reply = dbus_message_new_method_return(message);
|
|
if (!reply)
|
|
goto oom;
|
|
|
|
} else {
|
|
const BusBoundProperties bps[] = {
|
|
{ "org.freedesktop.machine1.Machine", bus_machine_machine_properties, m },
|
|
{ NULL, }
|
|
};
|
|
|
|
return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
|
|
}
|
|
|
|
if (reply) {
|
|
if (!bus_maybe_send_reply(connection, message, reply))
|
|
goto oom;
|
|
}
|
|
|
|
return DBUS_HANDLER_RESULT_HANDLED;
|
|
|
|
oom:
|
|
dbus_error_free(&error);
|
|
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
}
|
|
|
|
static DBusHandlerResult machine_message_handler(
|
|
DBusConnection *connection,
|
|
DBusMessage *message,
|
|
void *userdata) {
|
|
|
|
Manager *manager = userdata;
|
|
Machine *m;
|
|
int r;
|
|
|
|
r = get_machine_for_path(manager, dbus_message_get_path(message), &m);
|
|
if (r < 0) {
|
|
|
|
if (r == -ENOMEM)
|
|
return DBUS_HANDLER_RESULT_NEED_MEMORY;
|
|
|
|
if (r == -ENOENT) {
|
|
DBusError e;
|
|
|
|
dbus_error_init(&e);
|
|
dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown machine");
|
|
return bus_send_error_reply(connection, message, &e, r);
|
|
}
|
|
|
|
return bus_send_error_reply(connection, message, NULL, r);
|
|
}
|
|
|
|
return machine_message_dispatch(m, connection, message);
|
|
}
|
|
|
|
const DBusObjectPathVTable bus_machine_vtable = {
|
|
.message_function = machine_message_handler
|
|
};
|
|
|
|
char *machine_bus_path(Machine *m) {
|
|
_cleanup_free_ char *e = NULL;
|
|
|
|
assert(m);
|
|
|
|
e = bus_path_escape(m->name);
|
|
if (!e)
|
|
return NULL;
|
|
|
|
return strappend("/org/freedesktop/machine1/machine/", e);
|
|
}
|
|
|
|
int machine_send_signal(Machine *m, bool new_machine) {
|
|
_cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
assert(m);
|
|
|
|
msg = dbus_message_new_signal("/org/freedesktop/machine1",
|
|
"org.freedesktop.machine1.Manager",
|
|
new_machine ? "MachineNew" : "MachineRemoved");
|
|
|
|
if (!m)
|
|
return -ENOMEM;
|
|
|
|
p = machine_bus_path(m);
|
|
if (!p)
|
|
return -ENOMEM;
|
|
|
|
if (!dbus_message_append_args(
|
|
msg,
|
|
DBUS_TYPE_STRING, &m->name,
|
|
DBUS_TYPE_OBJECT_PATH, &p,
|
|
DBUS_TYPE_INVALID))
|
|
return -ENOMEM;
|
|
|
|
if (!dbus_connection_send(m->manager->bus, msg, NULL))
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int machine_send_changed(Machine *m, const char *properties) {
|
|
_cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
assert(m);
|
|
|
|
if (!m->started)
|
|
return 0;
|
|
|
|
p = machine_bus_path(m);
|
|
if (!p)
|
|
return -ENOMEM;
|
|
|
|
msg = bus_properties_changed_new(p, "org.freedesktop.machine1.Machine", properties);
|
|
if (!msg)
|
|
return -ENOMEM;
|
|
|
|
if (!dbus_connection_send(m->manager->bus, msg, NULL))
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int machine_send_create_reply(Machine *m, DBusError *error) {
|
|
_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
|
|
|
|
assert(m);
|
|
|
|
if (!m->create_message)
|
|
return 0;
|
|
|
|
if (error) {
|
|
DBusError buffer;
|
|
|
|
dbus_error_init(&buffer);
|
|
|
|
if (!error || !dbus_error_is_set(error)) {
|
|
dbus_set_error_const(&buffer, DBUS_ERROR_INVALID_ARGS, "Invalid Arguments");
|
|
error = &buffer;
|
|
}
|
|
|
|
reply = dbus_message_new_error(m->create_message, error->name, error->message);
|
|
dbus_error_free(&buffer);
|
|
|
|
if (!reply)
|
|
return log_oom();
|
|
} else {
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
p = machine_bus_path(m);
|
|
if (!p)
|
|
return log_oom();
|
|
|
|
reply = dbus_message_new_method_return(m->create_message);
|
|
if (!reply)
|
|
return log_oom();
|
|
|
|
if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &p, DBUS_TYPE_INVALID))
|
|
return log_oom();
|
|
}
|
|
|
|
if (!dbus_connection_send(m->manager->bus, reply, NULL))
|
|
return log_oom();
|
|
|
|
dbus_message_unref(m->create_message);
|
|
m->create_message = NULL;
|
|
|
|
return 0;
|
|
}
|