src/login/logind-user-dbus.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <string.h>
  24
  25 #include "strv.h"
  26 #include "bus-util.h"
  27
  28 #include "logind.h"
  29 #include "logind-user.h"
  30
  31 static int property_get_display(
  32                 sd_bus *bus,
  33                 const char *path,
  34                 const char *interface,
  35                 const char *property,
  36                 sd_bus_message *reply,
  37                 sd_bus_error *error,
  38                 void *userdata) {
  39
  40         _cleanup_free_ char *p = NULL;
  41         User *u = userdata;
  42
  43         assert(bus);
  44         assert(reply);
  45         assert(u);
  46
  47         p = u->display ? session_bus_path(u->display) : strdup("/");
  48         if (!p)
  49                 return -ENOMEM;
  50
  51         return sd_bus_message_append(reply, "(so)", u->display ? u->display->id : "", p);
  52 }
  53
  54 static int property_get_state(
  55                 sd_bus *bus,
  56                 const char *path,
  57                 const char *interface,
  58                 const char *property,
  59                 sd_bus_message *reply,
  60                 sd_bus_error *error,
  61                 void *userdata) {
  62
  63         User *u = userdata;
  64
  65         assert(bus);
  66         assert(reply);
  67         assert(u);
  68
  69         return sd_bus_message_append(reply, "s", user_state_to_string(user_get_state(u)));
  70 }
  71
  72 static int property_get_sessions(
  73                 sd_bus *bus,
  74                 const char *path,
  75                 const char *interface,
  76                 const char *property,
  77                 sd_bus_message *reply,
  78                 sd_bus_error *error,
  79                 void *userdata) {
  80
  81         User *u = userdata;
  82         Session *session;
  83         int r;
  84
  85         assert(bus);
  86         assert(reply);
  87         assert(u);
  88
  89         r = sd_bus_message_open_container(reply, 'a', "(so)");
  90         if (r < 0)
  91                 return r;
  92
  93         LIST_FOREACH(sessions_by_user, session, u->sessions) {
  94                 _cleanup_free_ char *p = NULL;
  95
  96                 p = session_bus_path(session);
  97                 if (!p)
  98                         return -ENOMEM;
  99
 100                 r = sd_bus_message_append(reply, "(so)", session->id, p);
 101                 if (r < 0)
 102                         return r;
 103
 104         }
 105
 106         r = sd_bus_message_close_container(reply);
 107         if (r < 0)
 108                 return r;
 109
 110         return 1;
 111 }
 112
 113 static int property_get_idle_hint(
 114                 sd_bus *bus,
 115                 const char *path,
 116                 const char *interface,
 117                 const char *property,
 118                 sd_bus_message *reply,
 119                 sd_bus_error *error,
 120                 void *userdata) {
 121
 122         User *u = userdata;
 123
 124         assert(bus);
 125         assert(reply);
 126         assert(u);
 127
 128         return sd_bus_message_append(reply, "b", user_get_idle_hint(u, NULL) > 0);
 129 }
 130
 131 static int property_get_idle_since_hint(
 132                 sd_bus *bus,
 133                 const char *path,
 134                 const char *interface,
 135                 const char *property,
 136                 sd_bus_message *reply,
 137                 sd_bus_error *error,
 138                 void *userdata) {
 139
 140         User *u = userdata;
 141         dual_timestamp t;
 142         uint64_t k;
 143
 144         assert(bus);
 145         assert(reply);
 146         assert(u);
 147
 148         user_get_idle_hint(u, &t);
 149         k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
 150
 151         return sd_bus_message_append(reply, "t", k);
 152 }
 153
 154 static int property_get_linger(
 155                 sd_bus *bus,
 156                 const char *path,
 157                 const char *interface,
 158                 const char *property,
 159                 sd_bus_message *reply,
 160                 sd_bus_error *error,
 161                 void *userdata) {
 162
 163         User *u = userdata;
 164         int r;
 165
 166         assert(bus);
 167         assert(reply);
 168         assert(u);
 169
 170         r = user_check_linger_file(u);
 171
 172         return sd_bus_message_append(reply, "b", r > 0);
 173 }
 174
 175 static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
 176         User *u = userdata;
 177         int r;
 178
 179         assert(bus);
 180         assert(message);
 181         assert(u);
 182
 183         r = user_stop(u);
 184         if (r < 0)
 185                 return sd_bus_reply_method_errno(message, r, NULL);
 186
 187         return sd_bus_reply_method_return(message, NULL);
 188 }
 189
 190 static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata) {
 191         User *u = userdata;
 192         int32_t signo;
 193         int r;
 194
 195         assert(bus);
 196         assert(message);
 197         assert(u);
 198
 199         r = sd_bus_message_read(message, "i", &signo);
 200         if (r < 0)
 201                 return sd_bus_reply_method_errno(message, r, NULL);
 202
 203         if (signo <= 0 || signo >= _NSIG)
 204                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
 205
 206         r = user_kill(u, signo);
 207         if (r < 0)
 208                 return sd_bus_reply_method_errno(message, r, NULL);
 209
 210         return sd_bus_reply_method_return(message, NULL);
 211 }
 212
 213 const sd_bus_vtable user_vtable[] = {
 214         SD_BUS_VTABLE_START(0),
 215
 216         SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(User, uid), 0),
 217         SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(User, gid), 0),
 218         SD_BUS_PROPERTY("Name", "s", NULL, offsetof(User, name), 0),
 219         SD_BUS_PROPERTY("Timestamp", "t", NULL, offsetof(User, timestamp.realtime), 0),
 220         SD_BUS_PROPERTY("TimestampMonotonic", "t", NULL, offsetof(User, timestamp.monotonic), 0),
 221         SD_BUS_PROPERTY("RuntimePath", "s", NULL, offsetof(User, runtime_path), 0),
 222         SD_BUS_PROPERTY("Service", "s", NULL, offsetof(User, service), 0),
 223         SD_BUS_PROPERTY("Slice", "s", NULL, offsetof(User, slice), 0),
 224         SD_BUS_PROPERTY("Display", "(so)", property_get_display, 0, 0),
 225         SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
 226         SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 227         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 228         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 229         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 230         SD_BUS_PROPERTY("Linger", "b", property_get_linger, 0, 0),
 231
 232         SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
 233         SD_BUS_METHOD("Kill", "i", NULL, method_kill, 0),
 234
 235         SD_BUS_VTABLE_END
 236 };
 237
 238 int user_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
 239         Manager *m = userdata;
 240         User *user;
 241         int r;
 242
 243         assert(bus);
 244         assert(path);
 245         assert(interface);
 246         assert(found);
 247         assert(m);
 248
 249         if (streq(path, "/org/freedesktop/login1/user/self")) {
 250                 sd_bus_message *message;
 251                 pid_t pid;
 252
 253                 message = sd_bus_get_current(bus);
 254                 if (!message)
 255                         return 0;
 256
 257                 r = sd_bus_get_owner_pid(bus, sd_bus_message_get_sender(message), &pid);
 258                 if (r < 0)
 259                         return 0;
 260
 261                 r = manager_get_user_by_pid(m, pid, &user);
 262                 if (r <= 0)
 263                         return 0;
 264         } else {
 265                 unsigned long lu;
 266                 const char *p;
 267
 268                 p = startswith(path, "/org/freedesktop/login1/user/_");
 269                 if (!p)
 270                         return 0;
 271
 272                 r = safe_atolu(p, &lu);
 273                 if (r < 0)
 274                         return 0;
 275
 276                 user = hashmap_get(m->users, ULONG_TO_PTR(lu));
 277                 if (!user)
 278                         return 0;
 279         }
 280
 281         *found = user;
 282         return 1;
 283 }
 284
 285 char *user_bus_path(User *u) {
 286         char *s;
 287
 288         assert(u);
 289
 290         if (asprintf(&s, "/org/freedesktop/login1/user/_%llu", (unsigned long long) u->uid) < 0)
 291                 return NULL;
 292
 293         return s;
 294 }
 295
 296 int user_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
 297         _cleanup_strv_free_ char **l = NULL;
 298         Manager *m = userdata;
 299         User *user;
 300         Iterator i;
 301         int r;
 302
 303         assert(bus);
 304         assert(path);
 305         assert(nodes);
 306
 307         HASHMAP_FOREACH(user, m->users, i) {
 308                 char *p;
 309
 310                 p = user_bus_path(user);
 311                 if (!p)
 312                         return -ENOMEM;
 313
 314                 r = strv_push(&l, p);
 315                 if (r < 0) {
 316                         free(p);
 317                         return r;
 318                 }
 319         }
 320
 321         *nodes = l;
 322         l = NULL;
 323
 324         return 1;
 325 }
 326
 327 int user_send_signal(User *u, bool new_user) {
 328         _cleanup_free_ char *p = NULL;
 329
 330         assert(u);
 331
 332         p = user_bus_path(u);
 333         if (!p)
 334                 return -ENOMEM;
 335
 336         return sd_bus_emit_signal(
 337                         u->manager->bus,
 338                         "/org/freedesktop/login1",
 339                         "org.freedesktop.login1.Manager",
 340                         new_user ? "UserNew" : "UserRemoved",
 341                         "uo", (uint32_t) u->uid, p);
 342 }
 343
 344 int user_send_changed(User *u, const char *properties, ...) {
 345         _cleanup_free_ char *p = NULL;
 346         char **l;
 347
 348         assert(u);
 349
 350         if (!u->started)
 351                 return 0;
 352
 353         p = user_bus_path(u);
 354         if (!p)
 355                 return -ENOMEM;
 356
 357         l = strv_from_stdarg_alloca(properties);
 358
 359         return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
 360 }