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