src/login/logind-seat-dbus.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <string.h>
   5
   6 #include "alloc-util.h"
   7 #include "bus-common-errors.h"
   8 #include "bus-label.h"
   9 #include "bus-util.h"
  10 #include "logind-seat.h"
  11 #include "logind.h"
  12 #include "strv.h"
  13 #include "user-util.h"
  14 #include "util.h"
  15
  16 static BUS_DEFINE_PROPERTY_GET(property_get_can_multi_session, "b", Seat, seat_can_multi_session);
  17 static BUS_DEFINE_PROPERTY_GET(property_get_can_tty, "b", Seat, seat_can_tty);
  18 static BUS_DEFINE_PROPERTY_GET(property_get_can_graphical, "b", Seat, seat_can_graphical);
  19
  20 static int property_get_active_session(
  21                 sd_bus *bus,
  22                 const char *path,
  23                 const char *interface,
  24                 const char *property,
  25                 sd_bus_message *reply,
  26                 void *userdata,
  27                 sd_bus_error *error) {
  28
  29         _cleanup_free_ char *p = NULL;
  30         Seat *s = userdata;
  31
  32         assert(bus);
  33         assert(reply);
  34         assert(s);
  35
  36         p = s->active ? session_bus_path(s->active) : strdup("/");
  37         if (!p)
  38                 return -ENOMEM;
  39
  40         return sd_bus_message_append(reply, "(so)", s->active ? s->active->id : "", p);
  41 }
  42
  43 static int property_get_sessions(
  44                 sd_bus *bus,
  45                 const char *path,
  46                 const char *interface,
  47                 const char *property,
  48                 sd_bus_message *reply,
  49                 void *userdata,
  50                 sd_bus_error *error) {
  51
  52         Seat *s = userdata;
  53         Session *session;
  54         int r;
  55
  56         assert(bus);
  57         assert(reply);
  58         assert(s);
  59
  60         r = sd_bus_message_open_container(reply, 'a', "(so)");
  61         if (r < 0)
  62                 return r;
  63
  64         LIST_FOREACH(sessions_by_seat, session, s->sessions) {
  65                 _cleanup_free_ char *p = NULL;
  66
  67                 p = session_bus_path(session);
  68                 if (!p)
  69                         return -ENOMEM;
  70
  71                 r = sd_bus_message_append(reply, "(so)", session->id, p);
  72                 if (r < 0)
  73                         return r;
  74
  75         }
  76
  77         r = sd_bus_message_close_container(reply);
  78         if (r < 0)
  79                 return r;
  80
  81         return 1;
  82 }
  83
  84 static int property_get_idle_hint(
  85                 sd_bus *bus,
  86                 const char *path,
  87                 const char *interface,
  88                 const char *property,
  89                 sd_bus_message *reply,
  90                 void *userdata,
  91                 sd_bus_error *error) {
  92
  93         Seat *s = userdata;
  94
  95         assert(bus);
  96         assert(reply);
  97         assert(s);
  98
  99         return sd_bus_message_append(reply, "b", seat_get_idle_hint(s, NULL) > 0);
 100 }
 101
 102 static int property_get_idle_since_hint(
 103                 sd_bus *bus,
 104                 const char *path,
 105                 const char *interface,
 106                 const char *property,
 107                 sd_bus_message *reply,
 108                 void *userdata,
 109                 sd_bus_error *error) {
 110
 111         Seat *s = userdata;
 112         dual_timestamp t;
 113         uint64_t u;
 114         int r;
 115
 116         assert(bus);
 117         assert(reply);
 118         assert(s);
 119
 120         r = seat_get_idle_hint(s, &t);
 121         if (r < 0)
 122                 return r;
 123
 124         u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
 125
 126         return sd_bus_message_append(reply, "t", u);
 127 }
 128
 129 int bus_seat_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 130         Seat *s = userdata;
 131         int r;
 132
 133         assert(message);
 134         assert(s);
 135
 136         r = bus_verify_polkit_async(
 137                         message,
 138                         CAP_KILL,
 139                         "org.freedesktop.login1.manage",
 140                         NULL,
 141                         false,
 142                         UID_INVALID,
 143                         &s->manager->polkit_registry,
 144                         error);
 145         if (r < 0)
 146                 return r;
 147         if (r == 0)
 148                 return 1; /* Will call us back */
 149
 150         r = seat_stop_sessions(s, true);
 151         if (r < 0)
 152                 return r;
 153
 154         return sd_bus_reply_method_return(message, NULL);
 155 }
 156
 157 static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 158         Seat *s = userdata;
 159         const char *name;
 160         Session *session;
 161         int r;
 162
 163         assert(message);
 164         assert(s);
 165
 166         r = sd_bus_message_read(message, "s", &name);
 167         if (r < 0)
 168                 return r;
 169
 170         session = hashmap_get(s->manager->sessions, name);
 171         if (!session)
 172                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
 173
 174         if (session->seat != s)
 175                 return sd_bus_error_setf(error, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", name, s->id);
 176
 177         r = session_activate(session);
 178         if (r < 0)
 179                 return r;
 180
 181         return sd_bus_reply_method_return(message, NULL);
 182 }
 183
 184 static int method_switch_to(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 185         Seat *s = userdata;
 186         unsigned int to;
 187         int r;
 188
 189         assert(message);
 190         assert(s);
 191
 192         r = sd_bus_message_read(message, "u", &to);
 193         if (r < 0)
 194                 return r;
 195
 196         if (to <= 0)
 197                 return -EINVAL;
 198
 199         r = seat_switch_to(s, to);
 200         if (r < 0)
 201                 return r;
 202
 203         return sd_bus_reply_method_return(message, NULL);
 204 }
 205
 206 static int method_switch_to_next(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 207         Seat *s = userdata;
 208         int r;
 209
 210         assert(message);
 211         assert(s);
 212
 213         r = seat_switch_to_next(s);
 214         if (r < 0)
 215                 return r;
 216
 217         return sd_bus_reply_method_return(message, NULL);
 218 }
 219
 220 static int method_switch_to_previous(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 221         Seat *s = userdata;
 222         int r;
 223
 224         assert(message);
 225         assert(s);
 226
 227         r = seat_switch_to_previous(s);
 228         if (r < 0)
 229                 return r;
 230
 231         return sd_bus_reply_method_return(message, NULL);
 232 }
 233
 234 const sd_bus_vtable seat_vtable[] = {
 235         SD_BUS_VTABLE_START(0),
 236
 237         SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Seat, id), SD_BUS_VTABLE_PROPERTY_CONST),
 238         SD_BUS_PROPERTY("ActiveSession", "(so)", property_get_active_session, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 239         SD_BUS_PROPERTY("CanMultiSession", "b", property_get_can_multi_session, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 240         SD_BUS_PROPERTY("CanTTY", "b", property_get_can_tty, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 241         SD_BUS_PROPERTY("CanGraphical", "b", property_get_can_graphical, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 242         SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, 0),
 243         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 244         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 245         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 246
 247         SD_BUS_METHOD("Terminate", NULL, NULL, bus_seat_method_terminate, SD_BUS_VTABLE_UNPRIVILEGED),
 248         SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, SD_BUS_VTABLE_UNPRIVILEGED),
 249         SD_BUS_METHOD("SwitchTo", "u", NULL, method_switch_to, SD_BUS_VTABLE_UNPRIVILEGED),
 250         SD_BUS_METHOD("SwitchToNext", NULL, NULL, method_switch_to_next, SD_BUS_VTABLE_UNPRIVILEGED),
 251         SD_BUS_METHOD("SwitchToPrevious", NULL, NULL, method_switch_to_previous, SD_BUS_VTABLE_UNPRIVILEGED),
 252
 253         SD_BUS_VTABLE_END
 254 };
 255
 256 int seat_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 257         Manager *m = userdata;
 258         Seat *seat;
 259         int r;
 260
 261         assert(bus);
 262         assert(path);
 263         assert(interface);
 264         assert(found);
 265         assert(m);
 266
 267         if (streq(path, "/org/freedesktop/login1/seat/self")) {
 268                 sd_bus_message *message;
 269
 270                 message = sd_bus_get_current_message(bus);
 271                 if (!message)
 272                         return 0;
 273
 274                 r = manager_get_seat_from_creds(m, message, NULL, error, &seat);
 275                 if (r < 0)
 276                         return r;
 277         } else {
 278                 _cleanup_free_ char *e = NULL;
 279                 const char *p;
 280
 281                 p = startswith(path, "/org/freedesktop/login1/seat/");
 282                 if (!p)
 283                         return 0;
 284
 285                 e = bus_label_unescape(p);
 286                 if (!e)
 287                         return -ENOMEM;
 288
 289                 seat = hashmap_get(m->seats, e);
 290                 if (!seat)
 291                         return 0;
 292         }
 293
 294         *found = seat;
 295         return 1;
 296 }
 297
 298 char *seat_bus_path(Seat *s) {
 299         _cleanup_free_ char *t = NULL;
 300
 301         assert(s);
 302
 303         t = bus_label_escape(s->id);
 304         if (!t)
 305                 return NULL;
 306
 307         return strappend("/org/freedesktop/login1/seat/", t);
 308 }
 309
 310 int seat_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 311         _cleanup_strv_free_ char **l = NULL;
 312         sd_bus_message *message;
 313         Manager *m = userdata;
 314         Seat *seat;
 315         Iterator i;
 316         int r;
 317
 318         assert(bus);
 319         assert(path);
 320         assert(nodes);
 321
 322         HASHMAP_FOREACH(seat, m->seats, i) {
 323                 char *p;
 324
 325                 p = seat_bus_path(seat);
 326                 if (!p)
 327                         return -ENOMEM;
 328
 329                 r = strv_consume(&l, p);
 330                 if (r < 0)
 331                         return r;
 332         }
 333
 334         message = sd_bus_get_current_message(bus);
 335         if (message) {
 336                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 337                 const char *name;
 338                 Session *session;
 339
 340                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_AUGMENT, &creds);
 341                 if (r >= 0) {
 342                         r = sd_bus_creds_get_session(creds, &name);
 343                         if (r >= 0) {
 344                                 session = hashmap_get(m->sessions, name);
 345                                 if (session && session->seat) {
 346                                         r = strv_extend(&l, "/org/freedesktop/login1/seat/self");
 347                                         if (r < 0)
 348                                                 return r;
 349                                 }
 350                         }
 351                 }
 352         }
 353
 354         *nodes = TAKE_PTR(l);
 355
 356         return 1;
 357 }
 358
 359 int seat_send_signal(Seat *s, bool new_seat) {
 360         _cleanup_free_ char *p = NULL;
 361
 362         assert(s);
 363
 364         p = seat_bus_path(s);
 365         if (!p)
 366                 return -ENOMEM;
 367
 368         return sd_bus_emit_signal(
 369                         s->manager->bus,
 370                         "/org/freedesktop/login1",
 371                         "org.freedesktop.login1.Manager",
 372                         new_seat ? "SeatNew" : "SeatRemoved",
 373                         "so", s->id, p);
 374 }
 375
 376 int seat_send_changed(Seat *s, const char *properties, ...) {
 377         _cleanup_free_ char *p = NULL;
 378         char **l;
 379
 380         assert(s);
 381
 382         if (!s->started)
 383                 return 0;
 384
 385         p = seat_bus_path(s);
 386         if (!p)
 387                 return -ENOMEM;
 388
 389         l = strv_from_stdarg_alloca(properties);
 390
 391         return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Seat", l);
 392 }