X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flogin%2Flogind-user-dbus.c;h=b034515203465e548c6da9d9c8b4a95cd75130b1;hp=8cc1dd49fde26500ad877a6a82ed13cdeb696137;hb=5b12334d35eadf1f45cc3d631fd1a2e72ffaea0a;hpb=4654e558a3c297a71f05c3b2db6a2744fcf3cdea diff --git a/src/login/logind-user-dbus.c b/src/login/logind-user-dbus.c index 8cc1dd49f..b03451520 100644 --- a/src/login/logind-user-dbus.c +++ b/src/login/logind-user-dbus.c @@ -22,374 +22,333 @@ #include #include +#include "strv.h" +#include "bus-util.h" + #include "logind.h" #include "logind-user.h" -#include "dbus-common.h" - -#define BUS_USER_INTERFACE \ - " \n" \ - " \n" \ - " \n" \ - " \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_USER_INTERFACE \ - BUS_PROPERTIES_INTERFACE \ - BUS_PEER_INTERFACE \ - BUS_INTROSPECTABLE_INTERFACE \ - "\n" - -#define INTERFACES_LIST \ - BUS_GENERIC_INTERFACES_LIST \ - "org.freedesktop.login1.User\0" - -static int bus_user_append_display(DBusMessageIter *i, const char *property, void *data) { - DBusMessageIter sub; - User *u = data; - const char *id, *path; - char _cleanup_free_ *p = NULL; - - assert(i); - assert(property); - assert(u); - - if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub)) - return -ENOMEM; - if (u->display) { - id = u->display->id; - path = p = session_bus_path(u->display); +static int property_get_display( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { - if (!p) - return -ENOMEM; - } else { - id = ""; - path = "/"; - } + _cleanup_free_ char *p = NULL; + User *u = userdata; - if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) || - !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path)) - return -ENOMEM; + assert(bus); + assert(reply); + assert(u); - if (!dbus_message_iter_close_container(i, &sub)) + p = u->display ? session_bus_path(u->display) : strdup("/"); + if (!p) return -ENOMEM; - return 0; + return sd_bus_message_append(reply, "(so)", u->display ? u->display->id : "", p); } -static int bus_user_append_state(DBusMessageIter *i, const char *property, void *data) { - User *u = data; - const char *state; - - assert(i); - assert(property); - assert(u); +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) { - state = user_state_to_string(user_get_state(u)); + User *u = userdata; - if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state)) - return -ENOMEM; + assert(bus); + assert(reply); + assert(u); - return 0; + return sd_bus_message_append(reply, "s", user_state_to_string(user_get_state(u))); } -static int bus_user_append_sessions(DBusMessageIter *i, const char *property, void *data) { - DBusMessageIter sub, sub2; - User *u = data; +static int property_get_sessions( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + User *u = userdata; Session *session; + int r; - assert(i); - assert(property); + assert(bus); + assert(reply); assert(u); - if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(so)", &sub)) - return -ENOMEM; + r = sd_bus_message_open_container(reply, 'a', "(so)"); + if (r < 0) + return r; LIST_FOREACH(sessions_by_user, session, u->sessions) { - char *p; - - if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2)) - return -ENOMEM; + _cleanup_free_ char *p = NULL; p = session_bus_path(session); if (!p) return -ENOMEM; - if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) || - !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) { - free(p); - return -ENOMEM; - } - - free(p); + r = sd_bus_message_append(reply, "(so)", session->id, p); + if (r < 0) + return r; - if (!dbus_message_iter_close_container(&sub, &sub2)) - return -ENOMEM; } - if (!dbus_message_iter_close_container(i, &sub)) - return -ENOMEM; + r = sd_bus_message_close_container(reply); + if (r < 0) + return r; - return 0; + return 1; } -static int bus_user_append_idle_hint(DBusMessageIter *i, const char *property, void *data) { - User *u = data; - dbus_bool_t b; +static int property_get_idle_hint( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { - assert(i); - assert(property); - assert(u); + User *u = userdata; - b = user_get_idle_hint(u, NULL) > 0; - - if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b)) - return -ENOMEM; + assert(bus); + assert(reply); + assert(u); - return 0; + return sd_bus_message_append(reply, "b", user_get_idle_hint(u, NULL) > 0); } -static int bus_user_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) { - User *u = data; +static int property_get_idle_since_hint( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + User *u = userdata; dual_timestamp t; uint64_t k; - assert(i); - assert(property); + assert(bus); + assert(reply); assert(u); user_get_idle_hint(u, &t); k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic; - if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &k)) - return -ENOMEM; + return sd_bus_message_append(reply, "t", k); +} - return 0; +static int property_get_linger( + sd_bus *bus, + const char *path, + const char *interface, + const char *property, + sd_bus_message *reply, + void *userdata, + sd_bus_error *error) { + + User *u = userdata; + int r; + + assert(bus); + assert(reply); + assert(u); + + r = user_check_linger_file(u); + + return sd_bus_message_append(reply, "b", r > 0); } -static int bus_user_append_default_cgroup(DBusMessageIter *i, const char *property, void *data) { - User *u = data; - char _cleanup_free_ *t = NULL; +static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) { + User *u = userdata; int r; - bool success; - assert(i); - assert(property); + assert(bus); + assert(message); assert(u); - r = cg_join_spec(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &t); + r = user_stop(u); if (r < 0) return r; - success = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t); - return success ? 0 : -ENOMEM; + return sd_bus_reply_method_return(message, NULL); } -static int get_user_for_path(Manager *m, const char *path, User **_u) { - User *u; - unsigned long lu; +static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) { + User *u = userdata; + int32_t signo; int r; - assert(m); - assert(path); - assert(_u); - - if (!startswith(path, "/org/freedesktop/login1/user/")) - return -EINVAL; + assert(bus); + assert(message); + assert(u); - r = safe_atolu(path + 29, &lu); + r = sd_bus_message_read(message, "i", &signo); if (r < 0) return r; - u = hashmap_get(m->users, ULONG_TO_PTR(lu)); - if (!u) - return -ENOENT; + if (signo <= 0 || signo >= _NSIG) + return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo); - *_u = u; - return 0; + r = user_kill(u, signo); + if (r < 0) + return r; + + return sd_bus_reply_method_return(message, NULL); } -static const BusProperty bus_login_user_properties[] = { - { "UID", bus_property_append_uid, "u", offsetof(User, uid) }, - { "GID", bus_property_append_gid, "u", offsetof(User, gid) }, - { "Name", bus_property_append_string, "s", offsetof(User, name), true }, - { "Timestamp", bus_property_append_usec, "t", offsetof(User, timestamp.realtime) }, - { "TimestampMonotonic", bus_property_append_usec, "t", offsetof(User, timestamp.monotonic) }, - { "RuntimePath", bus_property_append_string, "s", offsetof(User, runtime_path), true }, - { "DefaultControlGroup", bus_user_append_default_cgroup, "s", 0 }, - { "Service", bus_property_append_string, "s", offsetof(User, service), true }, - { "Display", bus_user_append_display, "(so)", 0 }, - { "State", bus_user_append_state, "s", 0 }, - { "Sessions", bus_user_append_sessions, "a(so)", 0 }, - { "IdleHint", bus_user_append_idle_hint, "b", 0 }, - { "IdleSinceHint", bus_user_append_idle_hint_since, "t", 0 }, - { "IdleSinceHintMonotonic", bus_user_append_idle_hint_since, "t", 0 }, - { NULL, } +const sd_bus_vtable user_vtable[] = { + SD_BUS_VTABLE_START(0), + + SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(User, uid), 0), + SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(User, gid), 0), + SD_BUS_PROPERTY("Name", "s", NULL, offsetof(User, name), 0), + SD_BUS_PROPERTY("Timestamp", "t", NULL, offsetof(User, timestamp.realtime), 0), + SD_BUS_PROPERTY("TimestampMonotonic", "t", NULL, offsetof(User, timestamp.monotonic), 0), + SD_BUS_PROPERTY("RuntimePath", "s", NULL, offsetof(User, runtime_path), 0), + SD_BUS_PROPERTY("Service", "s", NULL, offsetof(User, service), 0), + SD_BUS_PROPERTY("Slice", "s", NULL, offsetof(User, slice), 0), + SD_BUS_PROPERTY("Display", "(so)", property_get_display, 0, 0), + SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0), + SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE), + SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE), + SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE), + SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE), + SD_BUS_PROPERTY("Linger", "b", property_get_linger, 0, 0), + + SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0), + SD_BUS_METHOD("Kill", "i", NULL, method_kill, 0), + + SD_BUS_VTABLE_END }; -static DBusHandlerResult user_message_dispatch( - User *u, - DBusConnection *connection, - DBusMessage *message) { - - DBusError error; - _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; +int user_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) { + Manager *m = userdata; + User *user; int r; - assert(u); - assert(connection); - assert(message); + assert(bus); + assert(path); + assert(interface); + assert(found); + assert(m); + + if (streq(path, "/org/freedesktop/login1/user/self")) { + _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL; + sd_bus_message *message; + pid_t pid; - if (dbus_message_is_method_call(message, "org.freedesktop.login1.User", "Terminate")) { + message = sd_bus_get_current(bus); + if (!message) + return 0; - r = user_stop(u); + r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds); if (r < 0) - return bus_send_error_reply(connection, message, NULL, r); + return r; - reply = dbus_message_new_method_return(message); - if (!reply) - goto oom; - } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.User", "Kill")) { - int32_t signo; + r = sd_bus_creds_get_pid(creds, &pid); + if (r < 0) + return r; - if (!dbus_message_get_args( - message, - &error, - DBUS_TYPE_INT32, &signo, - DBUS_TYPE_INVALID)) - return bus_send_error_reply(connection, message, &error, -EINVAL); + r = manager_get_user_by_pid(m, pid, &user); + if (r <= 0) + return 0; + } else { + unsigned long lu; + const char *p; - if (signo <= 0 || signo >= _NSIG) - return bus_send_error_reply(connection, message, &error, -EINVAL); + p = startswith(path, "/org/freedesktop/login1/user/_"); + if (!p) + return 0; - r = user_kill(u, signo); + r = safe_atolu(p, &lu); if (r < 0) - return bus_send_error_reply(connection, message, NULL, r); - - reply = dbus_message_new_method_return(message); - if (!reply) - goto oom; + return 0; - } else { - const BusBoundProperties bps[] = { - { "org.freedesktop.login1.User", bus_login_user_properties, u }, - { NULL, } - }; - - return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps); + user = hashmap_get(m->users, ULONG_TO_PTR(lu)); + if (!user) + return 0; } - if (reply) { - if (!bus_maybe_send_reply(connection, message, reply)) - goto oom; - } + *found = user; + return 1; +} - return DBUS_HANDLER_RESULT_HANDLED; +char *user_bus_path(User *u) { + char *s; -oom: - dbus_error_free(&error); + assert(u); - return DBUS_HANDLER_RESULT_NEED_MEMORY; -} + if (asprintf(&s, "/org/freedesktop/login1/user/_%llu", (unsigned long long) u->uid) < 0) + return NULL; -static DBusHandlerResult user_message_handler( - DBusConnection *connection, - DBusMessage *message, - void *userdata) { + return s; +} +int user_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) { + _cleanup_strv_free_ char **l = NULL; Manager *m = userdata; - User *u; + User *user; + Iterator i; int r; - r = get_user_for_path(m, dbus_message_get_path(message), &u); - if (r < 0) { + assert(bus); + assert(path); + assert(nodes); - if (r == -ENOMEM) - return DBUS_HANDLER_RESULT_NEED_MEMORY; + HASHMAP_FOREACH(user, m->users, i) { + char *p; - if (r == -ENOENT) { - DBusError e; + p = user_bus_path(user); + if (!p) + return -ENOMEM; - dbus_error_init(&e); - dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown user"); - return bus_send_error_reply(connection, message, &e, r); + r = strv_push(&l, p); + if (r < 0) { + free(p); + return r; } - - return bus_send_error_reply(connection, message, NULL, r); } - return user_message_dispatch(u, connection, message); -} - -const DBusObjectPathVTable bus_user_vtable = { - .message_function = user_message_handler -}; - -char *user_bus_path(User *u) { - char *s; - - assert(u); - - if (asprintf(&s, "/org/freedesktop/login1/user/%llu", (unsigned long long) u->uid) < 0) - return NULL; + *nodes = l; + l = NULL; - return s; + return 1; } int user_send_signal(User *u, bool new_user) { - _cleanup_dbus_message_unref_ DBusMessage *m = NULL; _cleanup_free_ char *p = NULL; - uint32_t uid; assert(u); - m = dbus_message_new_signal("/org/freedesktop/login1", - "org.freedesktop.login1.Manager", - new_user ? "UserNew" : "UserRemoved"); - - if (!m) - return -ENOMEM; - p = user_bus_path(u); if (!p) return -ENOMEM; - uid = u->uid; - - if (!dbus_message_append_args( - m, - DBUS_TYPE_UINT32, &uid, - DBUS_TYPE_OBJECT_PATH, &p, - DBUS_TYPE_INVALID)) - return -ENOMEM; - - if (!dbus_connection_send(u->manager->bus, m, NULL)) - return -ENOMEM; - - return 0; + return sd_bus_emit_signal( + u->manager->bus, + "/org/freedesktop/login1", + "org.freedesktop.login1.Manager", + new_user ? "UserNew" : "UserRemoved", + "uo", (uint32_t) u->uid, p); } -int user_send_changed(User *u, const char *properties) { - _cleanup_dbus_message_unref_ DBusMessage *m = NULL; +int user_send_changed(User *u, const char *properties, ...) { _cleanup_free_ char *p = NULL; + char **l; assert(u); @@ -400,12 +359,7 @@ int user_send_changed(User *u, const char *properties) { if (!p) return -ENOMEM; - m = bus_properties_changed_new(p, "org.freedesktop.login1.User", properties); - if (!m) - return -ENOMEM; - - if (!dbus_connection_send(u->manager->bus, m, NULL)) - return -ENOMEM; + l = strv_from_stdarg_alloca(properties); - return 0; + return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l); }