picnoir
/
Systemd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Systemd/src/machine/machined-dbus.c

1114 lines
35 KiB
C
Raw Normal View History

machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
/*-*- 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 <unistd.h>
#include <pwd.h>
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
#include "sd-id128.h"
#include "sd-messages.h"
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
#include "strv.h"
#include "mkdir.h"
#include "path-util.h"
#include "special.h"
#include "fileio-label.h"
#include "label.h"
#include "utf8.h"
#include "unit-name.h"
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
#include "bus-util.h"
sd-bus: move common errors src/shared/bus-errors.h → src/libsystemd/sd-bus/bus-common-errors.h Stuff in src/shared/ should not use stuff from src/libsystemd/ really.
2014-12-10 19:00:46 +01:00
#include "bus-common-errors.h"
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
#include "time-util.h"
machine: add missing header include
2013-11-07 15:19:39 +01:00
#include "cgroup-util.h"
machined: Move image discovery logic into src/shared, so that we can make use of it from nspawn
2014-12-27 01:57:03 +01:00
#include "machine-image.h"
#include "image-dbus.h"
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
#include "machined.h"
machined: Move image discovery logic into src/shared, so that we can make use of it from nspawn
2014-12-27 01:57:03 +01:00
#include "machine-dbus.h"
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
static int method_get_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
_cleanup_free_ char *p = NULL;
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine = hashmap_get(m->machines, name);
if (!machine)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
p = machine_bus_path(machine);
if (!p)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return -ENOMEM;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
bus: let's simplify things by getting rid of unnecessary bus parameters
2013-11-21 01:51:16 +01:00
return sd_bus_reply_method_return(message, "o", p);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
machined: add new GetImage() bus call for retrieving the bus path for an image
2014-12-19 20:07:23 +01:00
static int method_get_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
Manager *m = userdata;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = image_find(name, NULL);
if (r == 0)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
if (r < 0)
return r;
p = image_bus_path(name);
if (!p)
return -ENOMEM;
return sd_bus_reply_method_return(message, "o", p);
}
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
static int method_get_machine_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
_cleanup_free_ char *p = NULL;
Manager *m = userdata;
Machine *machine = NULL;
logind: automatically determine client side PID if GetSessionByPID() is called with a PID == 0
2013-11-05 20:44:27 +01:00
pid_t pid;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
int r;
assert(bus);
assert(message);
assert(m);
logind: automatically determine client side PID if GetSessionByPID() is called with a PID == 0
2013-11-05 20:44:27 +01:00
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "u", &pid);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
logind: automatically determine client side PID if GetSessionByPID() is called with a PID == 0
2013-11-05 20:44:27 +01:00
if (pid == 0) {
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
if (r < 0)
return r;
r = sd_bus_creds_get_pid(creds, &pid);
logind: automatically determine client side PID if GetSessionByPID() is called with a PID == 0
2013-11-05 20:44:27 +01:00
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
logind: automatically determine client side PID if GetSessionByPID() is called with a PID == 0
2013-11-05 20:44:27 +01:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = manager_get_machine_by_pid(m, pid, &machine);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (!machine)
Remove unnecessary casts in printfs No functional change expected :)
2014-04-25 13:45:15 +02:00
return sd_bus_error_setf(error, BUS_ERROR_NO_MACHINE_FOR_PID, "PID "PID_FMT" does not belong to any known machine", pid);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
p = machine_bus_path(machine);
if (!p)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return -ENOMEM;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
bus: let's simplify things by getting rid of unnecessary bus parameters
2013-11-21 01:51:16 +01:00
return sd_bus_reply_method_return(message, "o", p);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
static int method_list_machines(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
Manager *m = userdata;
Machine *machine;
Iterator i;
int r;
assert(bus);
assert(message);
assert(m);
bus: let's simplify things by getting rid of unnecessary bus parameters
2013-11-21 01:51:16 +01:00
r = sd_bus_message_new_method_return(message, &reply);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_open_container(reply, 'a', "(ssso)");
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
HASHMAP_FOREACH(machine, m->machines, i) {
_cleanup_free_ char *p = NULL;
p = machine_bus_path(machine);
if (!p)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return -ENOMEM;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_append(reply, "(ssso)",
machine->name,
strempty(machine_class_to_string(machine->class)),
machine->service,
p);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_close_container(reply);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
return sd_bus_send(bus, reply, NULL);
}
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
static int method_create_or_register_machine(Manager *manager, sd_bus_message *message, bool read_network, Machine **_m, sd_bus_error *error) {
machined: sync to /run after job completed
2013-07-02 15:49:27 +02:00
const char *name, *service, *class, *root_directory;
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
const int32_t *netif = NULL;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
MachineClass c;
uint32_t leader;
sd_id128_t id;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
const void *v;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
Machine *m;
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
size_t n, n_netif = 0;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
int r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(manager);
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
assert(message);
assert(_m);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
sd-bus: support connecting to remote hosts, directly into containers systemctl -H root@foobar:waldi will now show a list of services running on container "waldi" on host "foobar", using "root" for authenticating at "foobar". Since entereing a container requires priviliges, this will only work correctly for root logins.
2014-07-03 01:17:26 +02:00
if (!machine_name_is_valid(name))
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine name");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read_array(message, 'y', &v, &n);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (n == 0)
id = SD_ID128_NULL;
else if (n == 16)
memcpy(&id, v, n);
else
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine ID parameter");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "ssus", &service, &class, &leader, &root_directory);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
if (read_network) {
size_t i;
r = sd_bus_message_read_array(message, 'i', (const void**) &netif, &n_netif);
if (r < 0)
return r;
n_netif /= sizeof(int32_t);
for (i = 0; i < n_netif; i++) {
if (netif[i] <= 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid network interface index %i", netif[i]);
}
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (isempty(class))
c = _MACHINE_CLASS_INVALID;
else {
c = machine_class_from_string(class);
if (c < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine class parameter");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (leader == 1)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (!isempty(root_directory) && !path_is_absolute(root_directory))
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root directory must be empty or an absolute path");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (leader == 0) {
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
if (r < 0)
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert_cc(sizeof(uint32_t) == sizeof(pid_t));
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (hashmap_get(manager->machines, name))
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, BUS_ERROR_MACHINE_EXISTS, "Machine '%s' already exists", name);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
r = manager_add_machine(manager, name, &m);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
m->leader = leader;
m->class = c;
m->id = id;
if (!isempty(service)) {
m->service = strdup(service);
if (!m->service) {
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
r = -ENOMEM;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
goto fail;
}
}
if (!isempty(root_directory)) {
m->root_directory = strdup(root_directory);
if (!m->root_directory) {
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
r = -ENOMEM;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
goto fail;
}
}
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
if (n_netif > 0) {
assert_cc(sizeof(int32_t) == sizeof(int));
m->netif = memdup(netif, sizeof(int32_t) * n_netif);
if (!m->netif) {
r = -ENOMEM;
goto fail;
}
m->n_netif = n_netif;
}
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
*_m = m;
return 1;
fail:
machine_add_to_gc_queue(m);
return r;
}
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
static int method_create_machine_internal(sd_bus *bus, sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
Manager *manager = userdata;
Machine *m = NULL;
int r;
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
r = method_create_or_register_machine(manager, message, read_network, &m, error);
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
if (r < 0)
return r;
r = sd_bus_message_enter_container(message, 'a', "(sv)");
if (r < 0)
goto fail;
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
r = machine_start(m, message, error);
if (r < 0)
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
goto fail;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
m->create_message = sd_bus_message_ref(message);
return 1;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
fail:
bus: fix access to unitialized variable in error path src/machine/machined-dbus.c:237:13: warning: Branch condition evaluates to a garbage value if (m) ^
2013-10-12 01:33:43 +02:00
machine_add_to_gc_queue(m);
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
return r;
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
static int method_create_machine_with_network(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
return method_create_machine_internal(bus, message, true, userdata, error);
}
static int method_create_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
return method_create_machine_internal(bus, message, false, userdata, error);
}
static int method_register_machine_internal(sd_bus *bus, sd_bus_message *message, bool read_network, void *userdata, sd_bus_error *error) {
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
Manager *manager = userdata;
_cleanup_free_ char *p = NULL;
Machine *m = NULL;
int r;
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
r = method_create_or_register_machine(manager, message, read_network, &m, error);
machined: optionally, allow registration of pre-existing units (scopes or services) as machine with machined
2014-02-11 17:15:38 +01:00
if (r < 0)
return r;
r = cg_pid_get_unit(m->leader, &m->unit);
if (r < 0) {
r = sd_bus_error_set_errnof(error, r, "Failed to determine unit of process "PID_FMT" : %s", m->leader, strerror(-r));
goto fail;
}
r = machine_start(m, NULL, error);
if (r < 0)
goto fail;
p = machine_bus_path(m);
if (!p) {
r = -ENOMEM;
goto fail;
}
return sd_bus_reply_method_return(message, "o", p);
fail:
machine_add_to_gc_queue(m);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
return r;
}
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
static int method_register_machine_with_network(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
return method_register_machine_internal(bus, message, true, userdata, error);
}
static int method_register_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
return method_register_machine_internal(bus, message, false, userdata, error);
}
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
static int method_terminate_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
Manager *m = userdata;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
Machine *machine;
const char *name;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
int r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(bus);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
assert(message);
assert(m);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine = hashmap_get(m->machines, name);
if (!machine)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: add logic to query IP addresses of containers
2014-05-18 13:48:53 +02:00
return bus_machine_method_terminate(bus, message, machine, error);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
static int method_kill_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(bus);
assert(message);
assert(m);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: add logic to query IP addresses of containers
2014-05-18 13:48:53 +02:00
r = sd_bus_message_read(message, "s", &name);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine = hashmap_get(m->machines, name);
if (!machine)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: add logic to query IP addresses of containers
2014-05-18 13:48:53 +02:00
return bus_machine_method_kill(bus, message, machine, error);
}
static int method_get_machine_addresses(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
return sd_bus_error_set_errno(error, r);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: add logic to query IP addresses of containers
2014-05-18 13:48:53 +02:00
machine = hashmap_get(m->machines, name);
if (!machine)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
return bus_machine_method_get_addresses(bus, message, machine, error);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machinectl: show /etc/os-release information of container in status output
2014-07-03 17:50:55 +02:00
static int method_get_machine_os_release(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return sd_bus_error_set_errno(error, r);
machine = hashmap_get(m->machines, name);
if (!machine)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
return bus_machine_method_get_os_release(bus, message, machine, error);
}
machined/machinectl: add logic to show list of available images This adds a new bus call to machined that enumerates /var/lib/container and returns all trees stored in it, distuingishing three types: - GPT disk images, which are files suffixed with ".gpt" - directory trees - btrfs subvolumes
2014-12-19 18:42:50 +01:00
static int method_list_images(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_(image_hashmap_freep) Hashmap *images = NULL;
Manager *m = userdata;
Image *image;
Iterator i;
int r;
assert(bus);
assert(message);
assert(m);
images = hashmap_new(&string_hash_ops);
if (!images)
return -ENOMEM;
r = image_discover(images);
if (r < 0)
return r;
r = sd_bus_message_new_method_return(message, &reply);
if (r < 0)
return r;
machined: add support for reporting image size via btrfs quota
2014-12-28 02:05:28 +01:00
r = sd_bus_message_open_container(reply, 'a', "(ssbttto)");
machined/machinectl: add logic to show list of available images This adds a new bus call to machined that enumerates /var/lib/container and returns all trees stored in it, distuingishing three types: - GPT disk images, which are files suffixed with ".gpt" - directory trees - btrfs subvolumes
2014-12-19 18:42:50 +01:00
if (r < 0)
return r;
HASHMAP_FOREACH(image, images, i) {
_cleanup_free_ char *p = NULL;
p = image_bus_path(image->name);
if (!p)
return -ENOMEM;
machined: add support for reporting image size via btrfs quota
2014-12-28 02:05:28 +01:00
r = sd_bus_message_append(reply, "(ssbttto)",
machined/machinectl: add logic to show list of available images This adds a new bus call to machined that enumerates /var/lib/container and returns all trees stored in it, distuingishing three types: - GPT disk images, which are files suffixed with ".gpt" - directory trees - btrfs subvolumes
2014-12-19 18:42:50 +01:00
image->name,
image_type_to_string(image->type),
image->read_only,
machined: beef up machined image listing with creation/modification times of subvolumes We make use of the btrfs subvol crtime for this, and for gpt images of a manually managed xattr, if we can.
2014-12-25 03:19:19 +01:00
image->crtime,
image->mtime,
machined: refer to the disk space allocated for an image to "usage" rather than "size" After all, it's closer to the "du"-reported value than to the file sizes...
2015-01-19 17:01:15 +01:00
image->usage,
machined/machinectl: add logic to show list of available images This adds a new bus call to machined that enumerates /var/lib/container and returns all trees stored in it, distuingishing three types: - GPT disk images, which are files suffixed with ".gpt" - directory trees - btrfs subvolumes
2014-12-19 18:42:50 +01:00
p);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(reply);
if (r < 0)
return r;
return sd_bus_send(bus, reply, NULL);
}
machined: add OpenMachinePTY() bus call for allocating a PTY device within a container Then, port "machinectl" over to make use of it.
2014-12-22 21:17:29 +01:00
static int method_open_machine_pty(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return sd_bus_error_set_errno(error, r);
machine = hashmap_get(m->machines, name);
if (!machine)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
return bus_machine_method_open_pty(bus, message, machine, error);
}
machined: add new call OpenMachineLogin() that starts a getty in a container on a pty and returns the pty master fd to the client This is a one-stop solution for "machinectl login", and should simplify getting logins in containers.
2014-12-23 19:12:49 +01:00
static int method_open_machine_login(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
machined: add "machinectl remove" for removing images
2014-12-27 02:35:47 +01:00
return r;
machined: add new call OpenMachineLogin() that starts a getty in a container on a pty and returns the pty master fd to the client This is a one-stop solution for "machinectl login", and should simplify getting logins in containers.
2014-12-23 19:12:49 +01:00
machine = hashmap_get(m->machines, name);
if (!machine)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
return bus_machine_method_open_login(bus, message, machine, error);
}
machined: move logic for bind mounting into containers from machinectl to machined This extends the bus interface, adding BindMountMachine() for bind mounting directories from the host into the container.
2015-02-17 17:19:57 +01:00
static int method_bind_mount_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
machine = hashmap_get(m->machines, name);
if (!machine)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
return bus_machine_method_bind_mount(bus, message, machine, error);
}
machined: make "machinectl copy-to" and "machinectl copy-from" server side operations This way, any bus client can make use of these calls.
2015-02-17 19:22:03 +01:00
static int method_copy_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = userdata;
Machine *machine;
const char *name;
int r;
assert(bus);
assert(message);
assert(m);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
machine = hashmap_get(m->machines, name);
if (!machine)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
return bus_machine_method_copy(bus, message, machine, error);
}
machined: add "machinectl remove" for removing images
2014-12-27 02:35:47 +01:00
static int method_remove_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(image_unrefp) Image* i = NULL;
const char *name;
int r;
assert(bus);
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
if (!image_name_is_valid(name))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", name);
r = image_find(name, &i);
if (r < 0)
return r;
if (r == 0)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
return bus_image_method_remove(bus, message, i, error);
machined: add "machinectl remove" for removing images
2014-12-27 02:35:47 +01:00
}
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
static int method_rename_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(image_unrefp) Image* i = NULL;
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
const char *old_name;
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
int r;
assert(bus);
assert(message);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
r = sd_bus_message_read(message, "s", &old_name);
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
if (r < 0)
return r;
if (!image_name_is_valid(old_name))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", old_name);
r = image_find(old_name, &i);
if (r < 0)
return r;
if (r == 0)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", old_name);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
return bus_image_method_rename(bus, message, i, error);
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
}
static int method_clone_image(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(image_unrefp) Image *i = NULL;
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
const char *old_name;
int r;
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
assert(bus);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
r = sd_bus_message_read(message, "s", &old_name);
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
if (r < 0)
return r;
if (!image_name_is_valid(old_name))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", old_name);
r = image_find(old_name, &i);
if (r < 0)
return r;
if (r == 0)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", old_name);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
return bus_image_method_clone(bus, message, i, error);
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
}
static int method_mark_image_read_only(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
_cleanup_(image_unrefp) Image *i = NULL;
const char *name;
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
int r;
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
assert(bus);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
r = sd_bus_message_read(message, "s", &name);
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
if (r < 0)
return r;
if (!image_name_is_valid(name))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Image name '%s' is invalid.", name);
r = image_find(name, &i);
if (r < 0)
return r;
if (r == 0)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_IMAGE, "No image '%s' known", name);
machined: don't look for images on each property get, but cache the image object inbetween
2014-12-28 02:44:37 +01:00
return bus_image_method_mark_read_only(bus, message, i, error);
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
const sd_bus_vtable manager_vtable[] = {
SD_BUS_VTABLE_START(0),
bus: introduce "trusted" bus concept and encode access control in object vtables Introduces a new concept of "trusted" vs. "untrusted" busses. For the latter libsystemd-bus will automatically do per-method access control, for the former all access is automatically granted. Per-method access control is encoded in the vtables: by default all methods are only accessible to privileged clients. If the SD_BUS_VTABLE_UNPRIVILEGED flag is set for a method it is accessible to unprivileged clients too. By default whether a client is privileged is determined via checking for its CAP_SYS_ADMIN capability, but this can be altered via the SD_BUS_VTABLE_CAPABILITY() macro that can be ORed into the flags field of the method. Writable properties are also subject to SD_BUS_VTABLE_UNPRIVILEGED and SD_BUS_VTABLE_CAPABILITY() for controlling write access to them. Note however that read access is unrestricted, as PropertiesChanged messages might send out the values anyway as an unrestricted broadcast. By default the system bus is set to "untrusted" and the user bus is "trusted" since per-method access control on the latter is unnecessary. On dbus1 busses we check the UID of the caller rather than the configured capability since the capability cannot be determined without race. On kdbus the capability is checked if possible from the attached meta-data of a message and otherwise queried from the sending peer. This also decorates the vtables of the various daemons we ship with these flags.
2013-12-10 17:41:39 +01:00
SD_BUS_METHOD("GetMachine", "s", "o", method_get_machine, SD_BUS_VTABLE_UNPRIVILEGED),
machined: add new GetImage() bus call for retrieving the bus path for an image
2014-12-19 20:07:23 +01:00
SD_BUS_METHOD("GetImage", "s", "o", method_get_image, SD_BUS_VTABLE_UNPRIVILEGED),
bus: introduce "trusted" bus concept and encode access control in object vtables Introduces a new concept of "trusted" vs. "untrusted" busses. For the latter libsystemd-bus will automatically do per-method access control, for the former all access is automatically granted. Per-method access control is encoded in the vtables: by default all methods are only accessible to privileged clients. If the SD_BUS_VTABLE_UNPRIVILEGED flag is set for a method it is accessible to unprivileged clients too. By default whether a client is privileged is determined via checking for its CAP_SYS_ADMIN capability, but this can be altered via the SD_BUS_VTABLE_CAPABILITY() macro that can be ORed into the flags field of the method. Writable properties are also subject to SD_BUS_VTABLE_UNPRIVILEGED and SD_BUS_VTABLE_CAPABILITY() for controlling write access to them. Note however that read access is unrestricted, as PropertiesChanged messages might send out the values anyway as an unrestricted broadcast. By default the system bus is set to "untrusted" and the user bus is "trusted" since per-method access control on the latter is unnecessary. On dbus1 busses we check the UID of the caller rather than the configured capability since the capability cannot be determined without race. On kdbus the capability is checked if possible from the attached meta-data of a message and otherwise queried from the sending peer. This also decorates the vtables of the various daemons we ship with these flags.
2013-12-10 17:41:39 +01:00
SD_BUS_METHOD("GetMachineByPID", "u", "o", method_get_machine_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD("ListMachines", NULL, "a(ssso)", method_list_machines, SD_BUS_VTABLE_UNPRIVILEGED),
machined: add support for reporting image size via btrfs quota
2014-12-28 02:05:28 +01:00
SD_BUS_METHOD("ListImages", NULL, "a(ssbttto)", method_list_images, SD_BUS_VTABLE_UNPRIVILEGED),
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
SD_BUS_METHOD("CreateMachine", "sayssusa(sv)", "o", method_create_machine, 0),
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
SD_BUS_METHOD("CreateMachineWithNetwork", "sayssusaia(sv)", "o", method_create_machine_with_network, 0),
machined: reorder method calls in vtable
2014-11-06 20:00:14 +01:00
SD_BUS_METHOD("RegisterMachine", "sayssus", "o", method_register_machine, 0),
machined: allow registering host-side network interfaces for communication with containers
2014-07-10 22:47:55 +02:00
SD_BUS_METHOD("RegisterMachineWithNetwork", "sayssusai", "o", method_register_machine_with_network, 0),
bus: introduce "trusted" bus concept and encode access control in object vtables Introduces a new concept of "trusted" vs. "untrusted" busses. For the latter libsystemd-bus will automatically do per-method access control, for the former all access is automatically granted. Per-method access control is encoded in the vtables: by default all methods are only accessible to privileged clients. If the SD_BUS_VTABLE_UNPRIVILEGED flag is set for a method it is accessible to unprivileged clients too. By default whether a client is privileged is determined via checking for its CAP_SYS_ADMIN capability, but this can be altered via the SD_BUS_VTABLE_CAPABILITY() macro that can be ORed into the flags field of the method. Writable properties are also subject to SD_BUS_VTABLE_UNPRIVILEGED and SD_BUS_VTABLE_CAPABILITY() for controlling write access to them. Note however that read access is unrestricted, as PropertiesChanged messages might send out the values anyway as an unrestricted broadcast. By default the system bus is set to "untrusted" and the user bus is "trusted" since per-method access control on the latter is unnecessary. On dbus1 busses we check the UID of the caller rather than the configured capability since the capability cannot be determined without race. On kdbus the capability is checked if possible from the attached meta-data of a message and otherwise queried from the sending peer. This also decorates the vtables of the various daemons we ship with these flags.
2013-12-10 17:41:39 +01:00
SD_BUS_METHOD("TerminateMachine", "s", NULL, method_terminate_machine, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
machined: make "machinectl copy-to" and "machinectl copy-from" server side operations This way, any bus client can make use of these calls.
2015-02-17 19:22:03 +01:00
SD_BUS_METHOD("KillMachine", "ssi", NULL, method_kill_machine, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)),
machined: fix address API signatures
2014-08-04 19:05:06 +02:00
SD_BUS_METHOD("GetMachineAddresses", "s", "a(iay)", method_get_machine_addresses, SD_BUS_VTABLE_UNPRIVILEGED),
machinectl: show /etc/os-release information of container in status output
2014-07-03 17:50:55 +02:00
SD_BUS_METHOD("GetMachineOSRelease", "s", "a{ss}", method_get_machine_os_release, SD_BUS_VTABLE_UNPRIVILEGED),
machined: add OpenMachinePTY() bus call for allocating a PTY device within a container Then, port "machinectl" over to make use of it.
2014-12-22 21:17:29 +01:00
SD_BUS_METHOD("OpenMachinePTY", "s", "hs", method_open_machine_pty, 0),
machined: introduce polkit for OpenLogin() call This way "machinectl login" can be opened up to run without privileges.
2014-12-23 21:28:22 +01:00
SD_BUS_METHOD("OpenMachineLogin", "s", "hs", method_open_machine_login, SD_BUS_VTABLE_UNPRIVILEGED),
machined: make "machinectl copy-to" and "machinectl copy-from" server side operations This way, any bus client can make use of these calls.
2015-02-17 19:22:03 +01:00
SD_BUS_METHOD("BindMountMachine", "sssbb", NULL, method_bind_mount_machine, 0),
SD_BUS_METHOD("CopyFromMachine", "sss", NULL, method_copy_machine, 0),
SD_BUS_METHOD("CopyToMachine", "sss", NULL, method_copy_machine, 0),
machined: add "machinectl remove" for removing images
2014-12-27 02:35:47 +01:00
SD_BUS_METHOD("RemoveImage", "s", NULL, method_remove_image, 0),
machinectl/machined: implement "rename", "clone", "read-only" verbs for machine images
2014-12-27 17:44:04 +01:00
SD_BUS_METHOD("RenameImage", "ss", NULL, method_rename_image, 0),
SD_BUS_METHOD("CloneImage", "ssb", NULL, method_clone_image, 0),
SD_BUS_METHOD("MarkImageReadOnly", "sb", NULL, method_mark_image_read_only, 0),
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
SD_BUS_SIGNAL("MachineNew", "so", 0),
SD_BUS_SIGNAL("MachineRemoved", "so", 0),
SD_BUS_VTABLE_END
};
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
const char *path, *result, *unit;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
Manager *m = userdata;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
Machine *machine;
uint32_t id;
int r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(bus);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
assert(message);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(m);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
if (r < 0) {
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
bus_log_parse_error(r);
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine = hashmap_get(m->machine_units, unit);
if (!machine)
return 0;
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (streq_ptr(path, machine->scope_job)) {
free(machine->scope_job);
machine->scope_job = NULL;
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (machine->started) {
if (streq(result, "done"))
machine_send_create_reply(machine, NULL);
else {
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
_cleanup_bus_error_free_ sd_bus_error e = SD_BUS_ERROR_NULL;
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
machine_send_create_reply(machine, &e);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
} else
machine_save(machine);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine_add_to_gc_queue(machine);
return 0;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
_cleanup_free_ char *unit = NULL;
Manager *m = userdata;
Machine *machine;
const char *path;
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(bus);
assert(message);
assert(m);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
path = sd_bus_message_get_path(message);
if (!path)
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
return 0;
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
r = unit_name_from_dbus_path(path, &unit);
machined: ignore spurious error
2014-12-29 19:08:50 +01:00
if (r == -EINVAL) /* not for a unit */
return 0;
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
if (r < 0)
return r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine = hashmap_get(m->machine_units, unit);
if (machine)
machine_add_to_gc_queue(machine);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
return 0;
}
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
const char *path, *unit;
Manager *m = userdata;
Machine *machine;
int r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(bus);
assert(message);
assert(m);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "so", &unit, &path);
if (r < 0) {
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
bus_log_parse_error(r);
return r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
machine = hashmap_get(m->machine_units, unit);
if (machine)
machine_add_to_gc_queue(machine);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
return 0;
}
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
Manager *m = userdata;
machined: simplifications
2013-11-05 00:52:46 +01:00
Machine *machine;
Iterator i;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
int b, r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(bus);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(message, "b", &b);
if (r < 0) {
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
bus_log_parse_error(r);
return r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
}
machined: simplifications
2013-11-05 00:52:46 +01:00
if (b)
return 0;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: simplifications
2013-11-05 00:52:46 +01:00
/* systemd finished reloading, let's recheck all our machines */
log_debug("System manager has been reloaded, rechecking machines...");
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
machined: simplifications
2013-11-05 00:52:46 +01:00
HASHMAP_FOREACH(machine, m->machines, i)
machine_add_to_gc_queue(machine);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
return 0;
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
int manager_start_scope(
Manager *manager,
const char *scope,
pid_t pid,
const char *slice,
const char *description,
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
sd_bus_message *more_properties,
sd_bus_error *error,
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
char **job) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
_cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
int r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
assert(manager);
assert(scope);
assert(pid > 1);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_new_method_call(
manager->bus,
api: in constructor function calls, always put the returned object pointer first (or second) Previously the returned object of constructor functions where sometimes returned as last, sometimes as first and sometimes as second parameter. Let's clean this up a bit. Here are the new rules: 1. The object the new object is derived from is put first, if there is any 2. The object we are creating will be returned in the next arguments 3. This is followed by any additional arguments Rationale: For functions that operate on an object we always put that object first. Constructors should probably not be too different in this regard. Also, if the additional parameters might want to use varargs which suggests to put them last. Note that this new scheme only applies to constructor functions, not to all other functions. We do give a lot of freedom for those. Note that this commit only changes the order of the new functions we added, for old ones we accept the wrong order and leave it like that.
2014-02-19 23:54:58 +01:00
&m,
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
api: in constructor function calls, always put the returned object pointer first (or second) Previously the returned object of constructor functions where sometimes returned as last, sometimes as first and sometimes as second parameter. Let's clean this up a bit. Here are the new rules: 1. The object the new object is derived from is put first, if there is any 2. The object we are creating will be returned in the next arguments 3. This is followed by any additional arguments Rationale: For functions that operate on an object we always put that object first. Constructors should probably not be too different in this regard. Also, if the additional parameters might want to use varargs which suggests to put them last. Note that this new scheme only applies to constructor functions, not to all other functions. We do give a lot of freedom for those. Note that this commit only changes the order of the new functions we added, for old ones we accept the wrong order and leave it like that.
2014-02-19 23:54:58 +01:00
"StartTransientUnit");
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: simplifications
2013-11-05 00:52:46 +01:00
r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_open_container(m, 'a', "(sv)");
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (!isempty(slice)) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
if (!isempty(description)) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
if (r < 0)
return r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
core: introduce new Delegate=yes/no property controlling creation of cgroup subhierarchies For priviliged units this resource control property ensures that the processes have all controllers systemd manages enabled. For unpriviliged services (those with User= set) this ensures that access rights to the service cgroup is granted to the user in question, to create further subgroups. Note that this only applies to the name=systemd hierarchy though, as access to other controllers is not safe for unpriviliged processes. Delegate=yes should be set for container scopes where a systemd instance inside the container shall manage the hierarchies below its own cgroup and have access to all controllers. Delegate=yes should also be set for user@.service, so that systemd --user can run, controlling its own cgroup tree. This commit changes machined, systemd-nspawn@.service and user@.service to set this boolean, in order to ensure that container management will just work, and the user systemd instance can run fine.
2014-11-05 17:57:23 +01:00
r = sd_bus_message_append(m, "(sv)", "Delegate", "b", 1);
if (r < 0)
return r;
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
if (more_properties) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_copy(m, more_properties, true);
machined: forward scope properties array from client to systemd This makes nspawn's --scope= switch work again.
2013-07-11 19:53:46 +02:00
if (r < 0)
return r;
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_close_container(m);
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
logind,machined,run: properly invoke StartTransientUnit() bus call
2013-11-21 20:05:49 +01:00
r = sd_bus_message_append(m, "a(sa(sv))", 0);
if (r < 0)
return r;
bus: rename sd_bus_send_with_reply_and_block() to sd_bus_call() The call is one of the most important ones we expose, where we place major emphasis on. We should make sure to give it a short, memorable name.
2013-11-11 18:55:34 +01:00
r = sd_bus_call(manager->bus, m, 0, error, &reply);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (job) {
const char *j;
char *copy;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(reply, "o", &j);
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
copy = strdup(j);
if (!copy)
return -ENOMEM;
*job = copy;
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
return 1;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
int r;
assert(manager);
assert(unit);
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_call_method(
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StopUnit",
error,
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
&reply,
"ss", unit, "fail");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (r < 0) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
if (job)
*job = NULL;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
sd_bus_error_free(error);
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
return 0;
}
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
return r;
}
if (job) {
const char *j;
char *copy;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(reply, "o", &j);
if (r < 0)
return r;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
copy = strdup(j);
if (!copy)
return -ENOMEM;
*job = copy;
}
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
return 1;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
machined: fix Kill() bus call on machine objects when "what" is specified as "leader"
2014-03-18 04:43:08 +01:00
int manager_kill_unit(Manager *manager, const char *unit, int signo, sd_bus_error *error) {
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
assert(manager);
assert(unit);
machined: simplifications
2013-11-05 00:52:46 +01:00
return sd_bus_call_method(
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"KillUnit",
error,
machined: simplifications
2013-11-05 00:52:46 +01:00
NULL,
machined: fix Kill() bus call on machine objects when "what" is specified as "leader"
2014-03-18 04:43:08 +01:00
"ssi", unit, "all", signo);
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
}
int manager_unit_is_active(Manager *manager, const char *unit) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
_cleanup_free_ char *path = NULL;
const char *state;
int r;
assert(manager);
assert(unit);
path = unit_dbus_path_from_name(unit);
if (!path)
return -ENOMEM;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_get_property(
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
manager->bus,
"org.freedesktop.systemd1",
path,
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
"org.freedesktop.systemd1.Unit",
"ActiveState",
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
&error,
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
&reply,
"s");
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
if (r < 0) {
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
return true;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
logind: don't misunderstand UnitRemoved signals during reloading When PID 1 reloads the units logind/machined will see UnitRemoved signals for all units. Instead of trusting these immediately, let's check the actual unit state before considering a unit gone, so that reloading PID 1 is not mistaken as the end of all sessions.
2013-07-10 23:31:40 +02:00
return false;
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
return r;
}
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_message_read(reply, "s", &state);
if (r < 0)
machined: split out machine registration stuff from logind 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.
2013-07-02 03:47:23 +02:00
return -EINVAL;
return !streq(state, "inactive") && !streq(state, "failed");
}
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
int manager_job_is_active(Manager *manager, const char *path) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
int r;
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
assert(manager);
assert(path);
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
r = sd_bus_get_property(
manager->bus,
"org.freedesktop.systemd1",
path,
"org.freedesktop.systemd1.Job",
"State",
&error,
&reply,
"s");
if (r < 0) {
if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
return true;
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
return false;
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
return r;
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
}
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
/* We don't actually care about the state really. The fact
* that we could read the job state is enough for us */
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
machined: port over to libsystemd-bus
2013-10-30 02:06:55 +01:00
return true;
Move functions around to fix underlinking in test-machine-tables
2013-09-25 13:26:08 +02:00
}
machine: move symbols referenced by shared code from main to shared file With --enable-address-sanitizer we get: machined-dbus.c:228: undefined reference to 'manager_add_machine'
2013-11-07 14:56:31 +01:00
int manager_get_machine_by_pid(Manager *m, pid_t pid, Machine **machine) {
_cleanup_free_ char *unit = NULL;
Machine *mm;
int r;
assert(m);
assert(pid >= 1);
assert(machine);
r = cg_pid_get_unit(pid, &unit);
if (r < 0)
mm = hashmap_get(m->machine_leaders, UINT_TO_PTR(pid));
else
mm = hashmap_get(m->machine_units, unit);
if (!mm)
return 0;
*machine = mm;
return 1;
}
int manager_add_machine(Manager *m, const char *name, Machine **_machine) {
Machine *machine;
assert(m);
assert(name);
machine = hashmap_get(m->machines, name);
if (!machine) {
machine = machine_new(m, name);
if (!machine)
return -ENOMEM;
}
if (_machine)
*_machine = machine;
return 0;
}