[thirdparty/systemd.git] / src / login / logind-machine-dbus.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 "logind.h"
#include "logind-machine.h"
#include "dbus-common.h"

#define BUS_MACHINE_INTERFACE \
        " <interface name=\"org.freedesktop.login1.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=\"DefaultControlGroup\" type=\"s\" access=\"read\"/>\n" \
        "  <property name=\"Service\" type=\"s\" access=\"read\"/>\n"   \
        "  <property name=\"Slice\" type=\"s\" access=\"read\"/>\n"     \
        "  <property name=\"Leader\" type=\"u\" access=\"read\"/>\n"    \
        "  <property name=\"Class\" 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.login1.Machine\0"

static int bus_machine_append_default_cgroup(DBusMessageIter *i, const char *property, void *data) {
        _cleanup_free_ char *t = NULL;
        Machine *m = data;
        int r;
        bool success;

        assert(i);
        assert(property);
        assert(m);

        r = cg_join_spec(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &t);
        if (r < 0)
                return r;

        success = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t);
        return success ? 0 : -ENOMEM;
}

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 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/login1/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_login_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) },
        { "DefaultControlGroup",    bus_machine_append_default_cgroup, "s", 0 },
        { "Service",                bus_property_append_string,        "s", offsetof(Machine, service),            true },
        { "Slice",                  bus_property_append_string,        "s", offsetof(Machine, slice),              true },
        { "Leader",                 bus_property_append_pid,           "u", offsetof(Session, leader)              },
        { "Class",                  bus_machine_append_class,          "s", offsetof(Machine, class)               },
        { "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.login1.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.login1.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.login1.Machine", bus_login_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/login1/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/login1",
                                    "org.freedesktop.login1.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.login1.Machine", properties);
        if (!msg)
                return -ENOMEM;

        if (!dbus_connection_send(m->manager->bus, msg, NULL))
                return -ENOMEM;

        return 0;
}
Commit	Line	Data
9444b1f2 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2011 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <errno.h>
	23	#include <string.h>
	24
	25	#include "logind.h"
	26	#include "logind-machine.h"
	27	#include "dbus-common.h"
	28
	29	#define BUS_MACHINE_INTERFACE \
	30	" <interface name=\"org.freedesktop.login1.Machine\">\n" \
	31	" <method name=\"Terminate\"/>\n" \
	32	" <method name=\"Kill\">\n" \
	33	" <arg name=\"who\" type=\"s\"/>\n" \
	34	" <arg name=\"signal\" type=\"s\"/>\n" \
	35	" </method>\n" \
	36	" <property name=\"Name\" type=\"s\" access=\"read\"/>\n" \
	37	" <property name=\"Id\" type=\"ay\" access=\"read\"/>\n" \
	38	" <property name=\"Timestamp\" type=\"t\" access=\"read\"/>\n" \
	39	" <property name=\"TimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
	40	" <property name=\"DefaultControlGroup\" type=\"s\" access=\"read\"/>\n" \
	41	" <property name=\"Service\" type=\"s\" access=\"read\"/>\n" \
	42	" <property name=\"Slice\" type=\"s\" access=\"read\"/>\n" \
	43	" <property name=\"Leader\" type=\"u\" access=\"read\"/>\n" \
	44	" <property name=\"Class\" type=\"s\" access=\"read\"/>\n" \
	45	" <property name=\"RootDirectory\" type=\"s\" access=\"read\"/>\n" \
	46	" </interface>\n"
	47
	48	#define INTROSPECTION \
	49	DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
	50	"<node>\n" \
	51	BUS_MACHINE_INTERFACE \
	52	BUS_PROPERTIES_INTERFACE \
	53	BUS_PEER_INTERFACE \
	54	BUS_INTROSPECTABLE_INTERFACE \
	55	"</node>\n"
	56
	57	#define INTERFACES_LIST \
	58	BUS_GENERIC_INTERFACES_LIST \
	59	"org.freedesktop.login1.Machine\0"
	60
	61	static int bus_machine_append_default_cgroup(DBusMessageIter i, const char property, void *data) {
	62	_cleanup_free_ char *t = NULL;
	63	Machine *m = data;
	64	int r;
65	bool success;
66
67	assert(i);
68	assert(property);
69	assert(m);
70
71	r = cg_join_spec(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &t);
72	if (r < 0)
73	return r;
74
75	success = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t);
76	return success ? 0 : -ENOMEM;
77	}
78
79	static int bus_machine_append_id(DBusMessageIter i, const char property, void *data) {
80	DBusMessageIter sub;
81	Machine *m = data;
82	dbus_bool_t b;
83	void *p;
84
85	assert(i);
86	assert(property);
87	assert(m);
88
89	if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub))
90	return -ENOMEM;
91
92	p = &m->id;
93	b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &p, 16);
94	if (!b)
95	return -ENOMEM;
96
97	if (!dbus_message_iter_close_container(i, &sub))
98	return -ENOMEM;
99
100	return 0;
101	}
102
103	static int get_machine_for_path(Manager m, const char path, Machine **_machine) {
104	_cleanup_free_ char *e = NULL;
105	Machine *machine;
106
107	assert(m);
108	assert(path);
109	assert(_machine);
110
111	if (!startswith(path, "/org/freedesktop/login1/machine/"))
112	return -EINVAL;
113
114	e = bus_path_unescape(path + 32);
115	if (!e)
116	return -ENOMEM;
117
118	machine = hashmap_get(m->machines, e);
119	if (!machine)
120	return -ENOENT;
121
122	*_machine = machine;
123	return 0;
124	}
125
126	static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_machine_append_class, machine_class, MachineClass);
127
128	static const BusProperty bus_login_machine_properties[] = {
129	{ "Name", bus_property_append_string, "s", offsetof(Machine, name), true },
130	{ "Id", bus_machine_append_id, "ay", 0 },
131	{ "Timestamp", bus_property_append_usec, "t", offsetof(Machine, timestamp.realtime) },
132	{ "TimestampMonotonic", bus_property_append_usec, "t", offsetof(Machine, timestamp.monotonic) },
133	{ "DefaultControlGroup", bus_machine_append_default_cgroup, "s", 0 },
134	{ "Service", bus_property_append_string, "s", offsetof(Machine, service), true },
135	{ "Slice", bus_property_append_string, "s", offsetof(Machine, slice), true },
136	{ "Leader", bus_property_append_pid, "u", offsetof(Session, leader) },
137	{ "Class", bus_machine_append_class, "s", offsetof(Machine, class) },
138	{ "RootDirectory", bus_property_append_string, "s", offsetof(Machine, root_directory), true },
139	{ NULL, }
140	};
141
142	static DBusHandlerResult machine_message_dispatch(
143	Machine *m,
144	DBusConnection *connection,
145	DBusMessage *message) {
146
147	DBusError error;
148	_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
149	int r;
150
151	assert(m);
152	assert(connection);
153	assert(message);
154
155	if (dbus_message_is_method_call(message, "org.freedesktop.login1.Machine", "Terminate")) {
156
157	r = machine_stop(m);
158	if (r < 0)
159	return bus_send_error_reply(connection, message, NULL, r);
160
161	reply = dbus_message_new_method_return(message);
162	if (!reply)
163	goto oom;
164
165	} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Machine", "Kill")) {
166	const char *swho;
167	int32_t signo;
168	KillWho who;
169
170	if (!dbus_message_get_args(
171	message,
172	&error,
173	DBUS_TYPE_STRING, &swho,
174	DBUS_TYPE_INT32, &signo,
175	DBUS_TYPE_INVALID))
176	return bus_send_error_reply(connection, message, &error, -EINVAL);
177
178	if (isempty(swho))
179	who = KILL_ALL;
180	else {
181	who = kill_who_from_string(swho);
182	if (who < 0)
183	return bus_send_error_reply(connection, message, &error, -EINVAL);
184	}
185
186	if (signo <= 0 \|\| signo >= _NSIG)
187	return bus_send_error_reply(connection, message, &error, -EINVAL);
188
189	r = machine_kill(m, who, signo);
190	if (r < 0)
191	return bus_send_error_reply(connection, message, NULL, r);
192
193	reply = dbus_message_new_method_return(message);
194	if (!reply)
195	goto oom;
196
197	} else {
198	const BusBoundProperties bps[] = {
199	{ "org.freedesktop.login1.Machine", bus_login_machine_properties, m },
200	{ NULL, }
201	};
202
203	return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
204	}
205
206	if (reply) {
207	if (!bus_maybe_send_reply(connection, message, reply))
208	goto oom;
209	}
210
211	return DBUS_HANDLER_RESULT_HANDLED;
212
213	oom:
214	dbus_error_free(&error);
215
216	return DBUS_HANDLER_RESULT_NEED_MEMORY;
217	}
218
219	static DBusHandlerResult machine_message_handler(
220	DBusConnection *connection,
221	DBusMessage *message,
222	void *userdata) {
223
224	Manager *manager = userdata;
225	Machine *m;
226	int r;
227
228	r = get_machine_for_path(manager, dbus_message_get_path(message), &m);
229	if (r < 0) {
230
231	if (r == -ENOMEM)
232	return DBUS_HANDLER_RESULT_NEED_MEMORY;
233
234	if (r == -ENOENT) {
235	DBusError e;
236
237	dbus_error_init(&e);
238	dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown machine");
239	return bus_send_error_reply(connection, message, &e, r);
240	}
241
242	return bus_send_error_reply(connection, message, NULL, r);
243	}
244
245	return machine_message_dispatch(m, connection, message);
246	}
247
248	const DBusObjectPathVTable bus_machine_vtable = {
249	.message_function = machine_message_handler
250	};
251
252	char machine_bus_path(Machine m) {
253	_cleanup_free_ char *e = NULL;
254
255	assert(m);
256
257	e = bus_path_escape(m->name);
258	if (!e)
259	return NULL;
260
261	return strappend("/org/freedesktop/login1/machine/", e);
262	}
263
264	int machine_send_signal(Machine *m, bool new_machine) {
265	_cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
266	_cleanup_free_ char *p = NULL;
267
268	assert(m);
269
270	msg = dbus_message_new_signal("/org/freedesktop/login1",
271	"org.freedesktop.login1.Manager",
272	new_machine ? "MachineNew" : "MachineRemoved");
273
274	if (!m)
275	return -ENOMEM;
276
277	p = machine_bus_path(m);
278	if (!p)
279	return -ENOMEM;
280
281	if (!dbus_message_append_args(
282	msg,
283	DBUS_TYPE_STRING, &m->name,
284	DBUS_TYPE_OBJECT_PATH, &p,
285	DBUS_TYPE_INVALID))
286	return -ENOMEM;
287
288	if (!dbus_connection_send(m->manager->bus, msg, NULL))
289	return -ENOMEM;
290
291	return 0;
292	}
293
294	int machine_send_changed(Machine m, const char properties) {
295	_cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
296	_cleanup_free_ char *p = NULL;
297
298	assert(m);
299
300	if (!m->started)
301	return 0;
302
303	p = machine_bus_path(m);
304	if (!p)
305	return -ENOMEM;
306
307	msg = bus_properties_changed_new(p, "org.freedesktop.login1.Machine", properties);
308	if (!msg)
309	return -ENOMEM;
310
311	if (!dbus_connection_send(m->manager->bus, msg, NULL))
312	return -ENOMEM;
313
314	return 0;
315	}