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 #include "logind.h"
  28 #include "logind-user.h"
  29 #include "formats-util.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                 void *userdata,
  38                 sd_bus_error *error) {
  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                 void *userdata,
  61                 sd_bus_error *error) {
  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                 void *userdata,
  79                 sd_bus_error *error) {
  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                 void *userdata,
 120                 sd_bus_error *error) {
 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                 void *userdata,
 138                 sd_bus_error *error) {
 139
 140         User *u = userdata;
 141         dual_timestamp t = DUAL_TIMESTAMP_NULL;
 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                 void *userdata,
 161                 sd_bus_error *error) {
 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 int bus_user_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 176         User *u = userdata;
 177         int r;
 178
 179         assert(message);
 180         assert(u);
 181
 182         r = bus_verify_polkit_async(
 183                         message,
 184                         CAP_KILL,
 185                         "org.freedesktop.login1.manage",
 186                         false,
 187                         u->uid,
 188                         &u->manager->polkit_registry,
 189                         error);
 190         if (r < 0)
 191                 return r;
 192         if (r == 0)
 193                 return 1; /* Will call us back */
 194
 195         r = user_stop(u, true);
 196         if (r < 0)
 197                 return r;
 198
 199         return sd_bus_reply_method_return(message, NULL);
 200 }
 201
 202 int bus_user_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 203         User *u = userdata;
 204         int32_t signo;
 205         int r;
 206
 207         assert(message);
 208         assert(u);
 209
 210         r = bus_verify_polkit_async(
 211                         message,
 212                         CAP_KILL,
 213                         "org.freedesktop.login1.manage",
 214                         false,
 215                         u->uid,
 216                         &u->manager->polkit_registry,
 217                         error);
 218         if (r < 0)
 219                 return r;
 220         if (r == 0)
 221                 return 1; /* Will call us back */
 222
 223         r = sd_bus_message_read(message, "i", &signo);
 224         if (r < 0)
 225                 return r;
 226
 227         if (signo <= 0 || signo >= _NSIG)
 228                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
 229
 230         r = user_kill(u, signo);
 231         if (r < 0)
 232                 return r;
 233
 234         return sd_bus_reply_method_return(message, NULL);
 235 }
 236
 237 const sd_bus_vtable user_vtable[] = {
 238         SD_BUS_VTABLE_START(0),
 239
 240         SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(User, uid), SD_BUS_VTABLE_PROPERTY_CONST),
 241         SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(User, gid), SD_BUS_VTABLE_PROPERTY_CONST),
 242         SD_BUS_PROPERTY("Name", "s", NULL, offsetof(User, name), SD_BUS_VTABLE_PROPERTY_CONST),
 243         BUS_PROPERTY_DUAL_TIMESTAMP("Timestamp", offsetof(User, timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
 244         SD_BUS_PROPERTY("RuntimePath", "s", NULL, offsetof(User, runtime_path), SD_BUS_VTABLE_PROPERTY_CONST),
 245         SD_BUS_PROPERTY("Service", "s", NULL, offsetof(User, service), SD_BUS_VTABLE_PROPERTY_CONST),
 246         SD_BUS_PROPERTY("Slice", "s", NULL, offsetof(User, slice), SD_BUS_VTABLE_PROPERTY_CONST),
 247         SD_BUS_PROPERTY("Display", "(so)", property_get_display, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 248         SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
 249         SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 250         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 251         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 252         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 253         SD_BUS_PROPERTY("Linger", "b", property_get_linger, 0, 0),
 254
 255         SD_BUS_METHOD("Terminate", NULL, NULL, bus_user_method_terminate, SD_BUS_VTABLE_UNPRIVILEGED),
 256         SD_BUS_METHOD("Kill", "i", NULL, bus_user_method_kill, SD_BUS_VTABLE_UNPRIVILEGED),
 257
 258         SD_BUS_VTABLE_END
 259 };
 260
 261 int user_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 262         Manager *m = userdata;
 263         uid_t uid;
 264         User *user;
 265         int r;
 266
 267         assert(bus);
 268         assert(path);
 269         assert(interface);
 270         assert(found);
 271         assert(m);
 272
 273         if (streq(path, "/org/freedesktop/login1/user/self")) {
 274                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 275                 sd_bus_message *message;
 276
 277                 message = sd_bus_get_current_message(bus);
 278                 if (!message)
 279                         return 0;
 280
 281                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
 282                 if (r < 0)
 283                         return r;
 284
 285                 r = sd_bus_creds_get_owner_uid(creds, &uid);
 286         } else {
 287                 const char *p;
 288
 289                 p = startswith(path, "/org/freedesktop/login1/user/_");
 290                 if (!p)
 291                         return 0;
 292
 293                 r = parse_uid(p, &uid);
 294         }
 295         if (r < 0)
 296                 return 0;
 297
 298         user = hashmap_get(m->users, UID_TO_PTR(uid));
 299         if (!user)
 300                 return 0;
 301
 302         *found = user;
 303         return 1;
 304 }
 305
 306 char *user_bus_path(User *u) {
 307         char *s;
 308
 309         assert(u);
 310
 311         if (asprintf(&s, "/org/freedesktop/login1/user/_"UID_FMT, u->uid) < 0)
 312                 return NULL;
 313
 314         return s;
 315 }
 316
 317 int user_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 318         _cleanup_strv_free_ char **l = NULL;
 319         sd_bus_message *message;
 320         Manager *m = userdata;
 321         User *user;
 322         Iterator i;
 323         int r;
 324
 325         assert(bus);
 326         assert(path);
 327         assert(nodes);
 328
 329         HASHMAP_FOREACH(user, m->users, i) {
 330                 char *p;
 331
 332                 p = user_bus_path(user);
 333                 if (!p)
 334                         return -ENOMEM;
 335
 336                 r = strv_consume(&l, p);
 337                 if (r < 0)
 338                         return r;
 339         }
 340
 341         message = sd_bus_get_current_message(bus);
 342         if (message) {
 343                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
 344                 uid_t uid;
 345
 346                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
 347                 if (r >= 0) {
 348                         r = sd_bus_creds_get_owner_uid(creds, &uid);
 349                         if (r >= 0) {
 350                                 user = hashmap_get(m->users, UID_TO_PTR(uid));
 351                                 if (user) {
 352                                         r = strv_extend(&l, "/org/freedesktop/login1/user/self");
 353                                         if (r < 0)
 354                                                 return r;
 355                                 }
 356                         }
 357                 }
 358         }
 359
 360         *nodes = l;
 361         l = NULL;
 362
 363         return 1;
 364 }
 365
 366 int user_send_signal(User *u, bool new_user) {
 367         _cleanup_free_ char *p = NULL;
 368
 369         assert(u);
 370
 371         p = user_bus_path(u);
 372         if (!p)
 373                 return -ENOMEM;
 374
 375         return sd_bus_emit_signal(
 376                         u->manager->bus,
 377                         "/org/freedesktop/login1",
 378                         "org.freedesktop.login1.Manager",
 379                         new_user ? "UserNew" : "UserRemoved",
 380                         "uo", (uint32_t) u->uid, p);
 381 }
 382
 383 int user_send_changed(User *u, const char *properties, ...) {
 384         _cleanup_free_ char *p = NULL;
 385         char **l;
 386
 387         assert(u);
 388
 389         if (!u->started)
 390                 return 0;
 391
 392         p = user_bus_path(u);
 393         if (!p)
 394                 return -ENOMEM;
 395
 396         l = strv_from_stdarg_alloca(properties);
 397
 398         return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
 399 }