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