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(bus, message, r, NULL);
 186
 187         return sd_bus_reply_method_return(bus, 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(bus, message, r, NULL);
 202
 203         if (signo <= 0 || signo >= _NSIG)
 204                 return sd_bus_reply_method_errorf(bus, 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(bus, message, r, NULL);
 209
 210         return sd_bus_reply_method_return(bus, 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
 240         _cleanup_free_ char *e = NULL;
 241         Manager *m = userdata;
 242         unsigned long lu;
 243         const char *p;
 244         User *user;
 245         int r;
 246
 247         assert(bus);
 248         assert(path);
 249         assert(interface);
 250         assert(found);
 251         assert(m);
 252
 253         p = startswith(path, "/org/freedesktop/login1/user/_");
 254         if (!p)
 255                 return 0;
 256
 257         r = safe_atolu(p, &lu);
 258         if (r < 0)
 259                 return 0;
 260
 261         user = hashmap_get(m->users, ULONG_TO_PTR(lu));
 262         if (!user)
 263                 return 0;
 264
 265         *found = user;
 266         return 1;
 267 }
 268
 269 char *user_bus_path(User *u) {
 270         char *s;
 271
 272         assert(u);
 273
 274         if (asprintf(&s, "/org/freedesktop/login1/user/_%llu", (unsigned long long) u->uid) < 0)
 275                 return NULL;
 276
 277         return s;
 278 }
 279
 280 int user_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
 281         _cleanup_strv_free_ char **l = NULL;
 282         Manager *m = userdata;
 283         User *user;
 284         Iterator i;
 285         int r;
 286
 287         assert(bus);
 288         assert(path);
 289         assert(nodes);
 290
 291         HASHMAP_FOREACH(user, m->users, i) {
 292                 char *p;
 293
 294                 p = user_bus_path(user);
 295                 if (!p)
 296                         return -ENOMEM;
 297
 298                 r = strv_push(&l, p);
 299                 if (r < 0) {
 300                         free(p);
 301                         return r;
 302                 }
 303         }
 304
 305         *nodes = l;
 306         l = NULL;
 307
 308         return 1;
 309 }
 310
 311 int user_send_signal(User *u, bool new_user) {
 312         _cleanup_free_ char *p = NULL;
 313
 314         assert(u);
 315
 316         p = user_bus_path(u);
 317         if (!p)
 318                 return -ENOMEM;
 319
 320         return sd_bus_emit_signal(
 321                         u->manager->bus,
 322                         "/org/freedesktop/login1",
 323                         "org.freedesktop.login1.Manager",
 324                         new_user ? "UserNew" : "UserRemoved",
 325                         "uo", (uint32_t) u->uid, p);
 326 }
 327
 328 int user_send_changed(User *u, const char *properties, ...) {
 329         _cleanup_free_ char *p = NULL;
 330         char **l;
 331
 332         assert(u);
 333
 334         if (!u->started)
 335                 return 0;
 336
 337         p = user_bus_path(u);
 338         if (!p)
 339                 return -ENOMEM;
 340
 341         l = strv_from_stdarg_alloca(properties);
 342
 343         return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
 344 }