X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fmachine%2Fmachine-dbus.c;h=a2fc56f7c9f8019c549a644740ab7e07c9e3953c;hp=ceab96e07832d375e3ae801f5dd98002a9edd8a5;hb=1d050e1e0a7082e23ee9b31fa0b819cb332b3444;hpb=76e665855edef5b7103cb09d114377d477bfae02 diff --git a/src/machine/machine-dbus.c b/src/machine/machine-dbus.c index ceab96e07..a2fc56f7c 100644 --- a/src/machine/machine-dbus.c +++ b/src/machine/machine-dbus.c @@ -21,344 +21,527 @@ #include #include - -#include "machined.h" +#include +#include + +#include "bus-util.h" +#include "bus-label.h" +#include "strv.h" +#include "bus-errors.h" +#include "copy.h" +#include "fileio.h" +#include "in-addr-util.h" +#include "local-addresses.h" #include "machine.h" -#include "dbus-common.h" - -#define BUS_MACHINE_INTERFACE \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" \ - " \n" - -#define INTROSPECTION \ - DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \ - "\n" \ - BUS_MACHINE_INTERFACE \ - BUS_PROPERTIES_INTERFACE \ - BUS_PEER_INTERFACE \ - BUS_INTROSPECTABLE_INTERFACE \ - "\n" - -#define INTERFACES_LIST \ - BUS_GENERIC_INTERFACES_LIST \ - "org.freedesktop.machine1.Machine\0" - -static int bus_machine_append_id(DBusMessageIter *i, const char *property, void *data) { - DBusMessageIter sub; - Machine *m = data; - dbus_bool_t b; - void *p; - - assert(i); - assert(property); - assert(m); - if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub)) - return -ENOMEM; +static int property_get_id( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { - p = &m->id; - b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &p, 16); - if (!b) - return -ENOMEM; + Machine *m = userdata; + int r; - if (!dbus_message_iter_close_container(i, &sub)) - return -ENOMEM; + assert(bus); + assert(reply); + assert(m); + + r = sd_bus_message_append_array(reply, 'y', &m->id, 16); + if (r < 0) + return r; - return 0; + return 1; } -static int bus_machine_append_state(DBusMessageIter *i, const char *property, void *data) { - Machine *m = data; +static int property_get_state( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + Machine *m = userdata; const char *state; + int r; - assert(i); - assert(property); + assert(bus); + assert(reply); assert(m); state = machine_state_to_string(machine_get_state(m)); - if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state)) - return -ENOMEM; + r = sd_bus_message_append_basic(reply, 's', state); + if (r < 0) + return r; - return 0; + return 1; } -static int get_machine_for_path(Manager *m, const char *path, Machine **_machine) { - _cleanup_free_ char *e = NULL; - Machine *machine; +static int property_get_netif( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { - assert(m); - assert(path); - assert(_machine); + Machine *m = userdata; + int r; - if (!startswith(path, "/org/freedesktop/machine1/machine/")) - return -EINVAL; + assert(bus); + assert(reply); + assert(m); - e = bus_path_unescape(path + 34); - if (!e) - return -ENOMEM; + assert_cc(sizeof(int) == sizeof(int32_t)); - machine = hashmap_get(m->machines, e); - if (!machine) - return -ENOENT; + r = sd_bus_message_append_array(reply, 'i', m->netif, m->n_netif * sizeof(int)); + if (r < 0) + return r; - *_machine = machine; - return 0; + return 1; } -static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_machine_append_class, machine_class, MachineClass); - -static const BusProperty bus_machine_machine_properties[] = { - { "Name", bus_property_append_string, "s", offsetof(Machine, name), true }, - { "Id", bus_machine_append_id, "ay", 0 }, - { "Timestamp", bus_property_append_usec, "t", offsetof(Machine, timestamp.realtime) }, - { "TimestampMonotonic", bus_property_append_usec, "t", offsetof(Machine, timestamp.monotonic) }, - { "Service", bus_property_append_string, "s", offsetof(Machine, service), true }, - { "Scope", bus_property_append_string, "s", offsetof(Machine, scope), true }, - { "Leader", bus_property_append_pid, "u", offsetof(Machine, leader) }, - { "Class", bus_machine_append_class, "s", offsetof(Machine, class) }, - { "State", bus_machine_append_state, "s", 0 }, - { "RootDirectory", bus_property_append_string, "s", offsetof(Machine, root_directory), true }, - { NULL, } -}; +static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_class, machine_class, MachineClass); + +int bus_machine_method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) { + Machine *m = userdata; + int r; + + assert(bus); + assert(message); + assert(m); + + r = machine_stop(m); + if (r < 0) + return r; -static DBusHandlerResult machine_message_dispatch( - Machine *m, - DBusConnection *connection, - DBusMessage *message) { + return sd_bus_reply_method_return(message, NULL); +} - DBusError error; - _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; +int bus_machine_method_kill(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) { + Machine *m = userdata; + const char *swho; + int32_t signo; + KillWho who; int r; + assert(bus); + assert(message); assert(m); - assert(connection); + + r = sd_bus_message_read(message, "si", &swho, &signo); + if (r < 0) + return r; + + if (isempty(swho)) + who = KILL_ALL; + else { + who = kill_who_from_string(swho); + if (who < 0) + return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho); + } + + if (signo <= 0 || signo >= _NSIG) + return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo); + + r = machine_kill(m, who, signo); + if (r < 0) + return r; + + return sd_bus_reply_method_return(message, NULL); +} + +int bus_machine_method_get_addresses(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) { + _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; + _cleanup_close_pair_ int pair[2] = { -1, -1 }; + _cleanup_free_ char *us = NULL, *them = NULL; + _cleanup_close_ int netns_fd = -1; + Machine *m = userdata; + const char *p; + siginfo_t si; + pid_t child; + int r; + + assert(bus); assert(message); + assert(m); + + r = readlink_malloc("/proc/self/ns/net", &us); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + p = procfs_file_alloca(m->leader, "ns/net"); + r = readlink_malloc(p, &them); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + if (streq(us, them)) + return sd_bus_error_setf(error, BUS_ERROR_NO_PRIVATE_NETWORKING, "Machine %s does not use private networking", m->name); + + r = namespace_open(m->leader, NULL, NULL, &netns_fd, NULL); + if (r < 0) + return sd_bus_error_set_errno(error, r); - if (dbus_message_is_method_call(message, "org.freedesktop.machine1.Machine", "Terminate")) { + if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, pair) < 0) + return sd_bus_error_set_errno(error, -errno); - r = machine_stop(m); + child = fork(); + if (child < 0) + return sd_bus_error_set_errno(error, -errno); + + if (child == 0) { + _cleanup_free_ struct local_address *addresses = NULL; + struct local_address *a; + int i, n; + + pair[0] = safe_close(pair[0]); + + r = namespace_enter(-1, -1, netns_fd, -1); if (r < 0) - return bus_send_error_reply(connection, message, NULL, r); - - reply = dbus_message_new_method_return(message); - if (!reply) - goto oom; - - } else if (dbus_message_is_method_call(message, "org.freedesktop.machine1.Machine", "Kill")) { - const char *swho; - int32_t signo; - KillWho who; - - if (!dbus_message_get_args( - message, - &error, - DBUS_TYPE_STRING, &swho, - DBUS_TYPE_INT32, &signo, - DBUS_TYPE_INVALID)) - return bus_send_error_reply(connection, message, &error, -EINVAL); - - if (isempty(swho)) - who = KILL_ALL; - else { - who = kill_who_from_string(swho); - if (who < 0) - return bus_send_error_reply(connection, message, &error, -EINVAL); + _exit(EXIT_FAILURE); + + n = local_addresses(NULL, 0, AF_UNSPEC, &addresses); + if (n < 0) + _exit(EXIT_FAILURE); + + for (a = addresses, i = 0; i < n; a++, i++) { + struct iovec iov[2] = { + { .iov_base = &a->family, .iov_len = sizeof(a->family) }, + { .iov_base = &a->address, .iov_len = FAMILY_ADDRESS_SIZE(a->family) }, + }; + + r = writev(pair[1], iov, 2); + if (r < 0) + _exit(EXIT_FAILURE); } - if (signo <= 0 || signo >= _NSIG) - return bus_send_error_reply(connection, message, &error, -EINVAL); + pair[1] = safe_close(pair[1]); - r = machine_kill(m, who, signo); - if (r < 0) - return bus_send_error_reply(connection, message, NULL, r); + _exit(EXIT_SUCCESS); + } - reply = dbus_message_new_method_return(message); - if (!reply) - goto oom; + pair[1] = safe_close(pair[1]); - } else { - const BusBoundProperties bps[] = { - { "org.freedesktop.machine1.Machine", bus_machine_machine_properties, m }, - { NULL, } + r = sd_bus_message_new_method_return(message, &reply); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + r = sd_bus_message_open_container(reply, 'a', "(iay)"); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + for (;;) { + int family; + ssize_t n; + union in_addr_union in_addr; + struct iovec iov[2]; + struct msghdr mh = { + .msg_iov = iov, + .msg_iovlen = 2, }; - return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps); - } + iov[0] = (struct iovec) { .iov_base = &family, .iov_len = sizeof(family) }; + iov[1] = (struct iovec) { .iov_base = &in_addr, .iov_len = sizeof(in_addr) }; - if (reply) { - if (!bus_maybe_send_reply(connection, message, reply)) - goto oom; + n = recvmsg(pair[0], &mh, 0); + if (n < 0) + return sd_bus_error_set_errno(error, -errno); + if ((size_t) n < sizeof(family)) + break; + + r = sd_bus_message_open_container(reply, 'r', "iay"); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + r = sd_bus_message_append(reply, "i", family); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + switch (family) { + + case AF_INET: + if (n != sizeof(struct in_addr) + sizeof(family)) + return sd_bus_error_set_errno(error, EIO); + + r = sd_bus_message_append_array(reply, 'y', &in_addr.in, sizeof(in_addr.in)); + break; + + case AF_INET6: + if (n != sizeof(struct in6_addr) + sizeof(family)) + return sd_bus_error_set_errno(error, EIO); + + r = sd_bus_message_append_array(reply, 'y', &in_addr.in6, sizeof(in_addr.in6)); + break; + } + if (r < 0) + return sd_bus_error_set_errno(error, r); + + r = sd_bus_message_close_container(reply); + if (r < 0) + return sd_bus_error_set_errno(error, r); } - return DBUS_HANDLER_RESULT_HANDLED; + r = wait_for_terminate(child, &si); + if (r < 0) + return sd_bus_error_set_errno(error, r); + if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS) + return sd_bus_error_set_errno(error, EIO); -oom: - dbus_error_free(&error); + r = sd_bus_message_close_container(reply); + if (r < 0) + return sd_bus_error_set_errno(error, r); - return DBUS_HANDLER_RESULT_NEED_MEMORY; + return sd_bus_send(bus, reply, NULL); } -static DBusHandlerResult machine_message_handler( - DBusConnection *connection, - DBusMessage *message, - void *userdata) { - - Manager *manager = userdata; - Machine *m; +int bus_machine_method_get_os_release(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) { + _cleanup_bus_message_unref_ sd_bus_message *reply = NULL; + _cleanup_close_ int mntns_fd = -1, root_fd = -1; + _cleanup_close_pair_ int pair[2] = { -1, -1 }; + _cleanup_strv_free_ char **l = NULL; + _cleanup_fclose_ FILE *f = NULL; + Machine *m = userdata; + char **k, **v; + siginfo_t si; + pid_t child; int r; - r = get_machine_for_path(manager, dbus_message_get_path(message), &m); - if (r < 0) { + assert(bus); + assert(message); + assert(m); - if (r == -ENOMEM) - return DBUS_HANDLER_RESULT_NEED_MEMORY; + r = namespace_open(m->leader, NULL, &mntns_fd, NULL, &root_fd); + if (r < 0) + return sd_bus_error_set_errno(error, r); - if (r == -ENOENT) { - DBusError e; + if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, pair) < 0) + return sd_bus_error_set_errno(error, -errno); - dbus_error_init(&e); - dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown machine"); - return bus_send_error_reply(connection, message, &e, r); + child = fork(); + if (child < 0) + return sd_bus_error_set_errno(error, -errno); + + if (child == 0) { + _cleanup_close_ int fd = -1; + + pair[0] = safe_close(pair[0]); + + r = namespace_enter(-1, mntns_fd, -1, root_fd); + if (r < 0) + _exit(EXIT_FAILURE); + + fd = open("/etc/os-release", O_RDONLY|O_CLOEXEC); + if (fd < 0) { + fd = open("/usr/lib/os-release", O_RDONLY|O_CLOEXEC); + if (fd < 0) + _exit(EXIT_FAILURE); } - return bus_send_error_reply(connection, message, NULL, r); + r = copy_bytes(fd, pair[1], (off_t) -1); + if (r < 0) + _exit(EXIT_FAILURE); + + _exit(EXIT_SUCCESS); } - return machine_message_dispatch(m, connection, message); + pair[1] = safe_close(pair[1]); + + f = fdopen(pair[0], "re"); + if (!f) + return sd_bus_error_set_errno(error, -errno); + + pair[0] = -1; + + r = load_env_file_pairs(f, "/etc/os-release", NULL, &l); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + r = wait_for_terminate(child, &si); + if (r < 0) + return sd_bus_error_set_errno(error, r); + if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS) + return sd_bus_error_set_errno(error, EIO); + + r = sd_bus_message_new_method_return(message, &reply); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + r = sd_bus_message_open_container(reply, 'a', "{ss}"); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + STRV_FOREACH_PAIR(k, v, l) { + r = sd_bus_message_append(reply, "{ss}", *k, *v); + if (r < 0) + return sd_bus_error_set_errno(error, r); + } + + r = sd_bus_message_close_container(reply); + if (r < 0) + return sd_bus_error_set_errno(error, r); + + return sd_bus_send(bus, reply, NULL); } -const DBusObjectPathVTable bus_machine_vtable = { - .message_function = machine_message_handler +const sd_bus_vtable machine_vtable[] = { + SD_BUS_VTABLE_START(0), + SD_BUS_PROPERTY("Name", "s", NULL, offsetof(Machine, name), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("Id", "ay", property_get_id, 0, SD_BUS_VTABLE_PROPERTY_CONST), + BUS_PROPERTY_DUAL_TIMESTAMP("Timestamp", offsetof(Machine, timestamp), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("Service", "s", NULL, offsetof(Machine, service), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("Unit", "s", NULL, offsetof(Machine, unit), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("Scope", "s", NULL, offsetof(Machine, unit), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN), + SD_BUS_PROPERTY("Leader", "u", NULL, offsetof(Machine, leader), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("Class", "s", property_get_class, offsetof(Machine, class), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("RootDirectory", "s", NULL, offsetof(Machine, root_directory), SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("NetworkInterfaces", "ai", property_get_netif, 0, SD_BUS_VTABLE_PROPERTY_CONST), + SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0), + SD_BUS_METHOD("Terminate", NULL, NULL, bus_machine_method_terminate, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)), + SD_BUS_METHOD("Kill", "si", NULL, bus_machine_method_kill, SD_BUS_VTABLE_CAPABILITY(CAP_KILL)), + SD_BUS_METHOD("GetAddresses", NULL, "a(iay)", bus_machine_method_get_addresses, SD_BUS_VTABLE_UNPRIVILEGED), + SD_BUS_METHOD("GetOSRelease", NULL, "a{ss}", bus_machine_method_get_os_release, SD_BUS_VTABLE_UNPRIVILEGED), + SD_BUS_VTABLE_END }; +int machine_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) { + Manager *m = userdata; + Machine *machine; + int r; + + assert(bus); + assert(path); + assert(interface); + assert(found); + assert(m); + + if (streq(path, "/org/freedesktop/machine1/machine/self")) { + _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL; + sd_bus_message *message; + pid_t pid; + + message = sd_bus_get_current_message(bus); + if (!message) + return 0; + + 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); + if (r < 0) + return r; + + r = manager_get_machine_by_pid(m, pid, &machine); + if (r <= 0) + return 0; + } else { + _cleanup_free_ char *e = NULL; + const char *p; + + p = startswith(path, "/org/freedesktop/machine1/machine/"); + if (!p) + return 0; + + e = bus_label_unescape(p); + if (!e) + return -ENOMEM; + + machine = hashmap_get(m->machines, e); + if (!machine) + return 0; + } + + *found = machine; + return 1; +} + char *machine_bus_path(Machine *m) { _cleanup_free_ char *e = NULL; assert(m); - e = bus_path_escape(m->name); + e = bus_label_escape(m->name); if (!e) return NULL; return strappend("/org/freedesktop/machine1/machine/", e); } -int machine_send_signal(Machine *m, bool new_machine) { - _cleanup_dbus_message_unref_ DBusMessage *msg = NULL; - _cleanup_free_ char *p = NULL; - - assert(m); +int machine_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) { + _cleanup_strv_free_ char **l = NULL; + Machine *machine = NULL; + Manager *m = userdata; + Iterator i; + int r; - msg = dbus_message_new_signal("/org/freedesktop/machine1", - "org.freedesktop.machine1.Manager", - new_machine ? "MachineNew" : "MachineRemoved"); + assert(bus); + assert(path); + assert(nodes); - if (!m) - return -ENOMEM; + HASHMAP_FOREACH(machine, m->machines, i) { + char *p; - p = machine_bus_path(m); - if (!p) - return -ENOMEM; + p = machine_bus_path(machine); + if (!p) + return -ENOMEM; - if (!dbus_message_append_args( - msg, - DBUS_TYPE_STRING, &m->name, - DBUS_TYPE_OBJECT_PATH, &p, - DBUS_TYPE_INVALID)) - return -ENOMEM; + r = strv_consume(&l, p); + if (r < 0) + return r; + } - if (!dbus_connection_send(m->manager->bus, msg, NULL)) - return -ENOMEM; + *nodes = l; + l = NULL; - return 0; + return 1; } -int machine_send_changed(Machine *m, const char *properties) { - _cleanup_dbus_message_unref_ DBusMessage *msg = NULL; +int machine_send_signal(Machine *m, bool new_machine) { _cleanup_free_ char *p = NULL; assert(m); - if (!m->started) - return 0; - p = machine_bus_path(m); if (!p) return -ENOMEM; - msg = bus_properties_changed_new(p, "org.freedesktop.machine1.Machine", properties); - if (!msg) - return -ENOMEM; - - if (!dbus_connection_send(m->manager->bus, msg, NULL)) - return -ENOMEM; - - return 0; + return sd_bus_emit_signal( + m->manager->bus, + "/org/freedesktop/machine1", + "org.freedesktop.machine1.Manager", + new_machine ? "MachineNew" : "MachineRemoved", + "so", m->name, p); } -int machine_send_create_reply(Machine *m, DBusError *error) { - _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; +int machine_send_create_reply(Machine *m, sd_bus_error *error) { + _cleanup_bus_message_unref_ sd_bus_message *c = NULL; + _cleanup_free_ char *p = NULL; assert(m); if (!m->create_message) return 0; - if (error) { - DBusError buffer; - - dbus_error_init(&buffer); - - if (!error || !dbus_error_is_set(error)) { - dbus_set_error_const(&buffer, DBUS_ERROR_INVALID_ARGS, "Invalid Arguments"); - error = &buffer; - } - - reply = dbus_message_new_error(m->create_message, error->name, error->message); - dbus_error_free(&buffer); - - if (!reply) - return log_oom(); - } else { - _cleanup_free_ char *p = NULL; - - p = machine_bus_path(m); - if (!p) - return log_oom(); + c = m->create_message; + m->create_message = NULL; - reply = dbus_message_new_method_return(m->create_message); - if (!reply) - return log_oom(); - - if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &p, DBUS_TYPE_INVALID)) - return log_oom(); - } + if (error) + return sd_bus_reply_method_error(c, error); /* Update the machine state file before we notify the client * about the result. */ machine_save(m); - if (!dbus_connection_send(m->manager->bus, reply, NULL)) - return log_oom(); - - dbus_message_unref(m->create_message); - m->create_message = NULL; + p = machine_bus_path(m); + if (!p) + return -ENOMEM; - return 0; + return sd_bus_reply_method_return(c, "o", p); }