src/login/logind-seat-dbus.c

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