src/login/logind-session-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-util.h"
   9 #include "fd-util.h"
  10 #include "logind-brightness.h"
  11 #include "logind-dbus.h"
  12 #include "logind-seat-dbus.h"
  13 #include "logind-session-dbus.h"
  14 #include "logind-session-device.h"
  15 #include "logind-session.h"
  16 #include "logind-user-dbus.h"
  17 #include "logind.h"
  18 #include "missing_capability.h"
  19 #include "path-util.h"
  20 #include "signal-util.h"
  21 #include "stat-util.h"
  22 #include "strv.h"
  23 #include "user-util.h"
  24 #include "util.h"
  25
  26 static int property_get_user(
  27                 sd_bus *bus,
  28                 const char *path,
  29                 const char *interface,
  30                 const char *property,
  31                 sd_bus_message *reply,
  32                 void *userdata,
  33                 sd_bus_error *error) {
  34
  35         _cleanup_free_ char *p = NULL;
  36         Session *s = userdata;
  37
  38         assert(bus);
  39         assert(reply);
  40         assert(s);
  41
  42         p = user_bus_path(s->user);
  43         if (!p)
  44                 return -ENOMEM;
  45
  46         return sd_bus_message_append(reply, "(uo)", (uint32_t) s->user->user_record->uid, p);
  47 }
  48
  49 static int property_get_name(
  50                 sd_bus *bus,
  51                 const char *path,
  52                 const char *interface,
  53                 const char *property,
  54                 sd_bus_message *reply,
  55                 void *userdata,
  56                 sd_bus_error *error) {
  57
  58         Session *s = userdata;
  59
  60         assert(bus);
  61         assert(reply);
  62         assert(s);
  63
  64         return sd_bus_message_append(reply, "s", s->user->user_record->user_name);
  65 }
  66
  67 static int property_get_seat(
  68                 sd_bus *bus,
  69                 const char *path,
  70                 const char *interface,
  71                 const char *property,
  72                 sd_bus_message *reply,
  73                 void *userdata,
  74                 sd_bus_error *error) {
  75
  76         _cleanup_free_ char *p = NULL;
  77         Session *s = userdata;
  78
  79         assert(bus);
  80         assert(reply);
  81         assert(s);
  82
  83         p = s->seat ? seat_bus_path(s->seat) : strdup("/");
  84         if (!p)
  85                 return -ENOMEM;
  86
  87         return sd_bus_message_append(reply, "(so)", s->seat ? s->seat->id : "", p);
  88 }
  89
  90 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, session_type, SessionType);
  91 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_class, session_class, SessionClass);
  92 static BUS_DEFINE_PROPERTY_GET(property_get_active, "b", Session, session_is_active);
  93 static BUS_DEFINE_PROPERTY_GET2(property_get_state, "s", Session, session_get_state, session_state_to_string);
  94
  95 static int property_get_idle_hint(
  96                 sd_bus *bus,
  97                 const char *path,
  98                 const char *interface,
  99                 const char *property,
 100                 sd_bus_message *reply,
 101                 void *userdata,
 102                 sd_bus_error *error) {
 103
 104         Session *s = userdata;
 105
 106         assert(bus);
 107         assert(reply);
 108         assert(s);
 109
 110         return sd_bus_message_append(reply, "b", session_get_idle_hint(s, NULL) > 0);
 111 }
 112
 113 static int property_get_idle_since_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         Session *s = userdata;
 123         dual_timestamp t = DUAL_TIMESTAMP_NULL;
 124         uint64_t u;
 125         int r;
 126
 127         assert(bus);
 128         assert(reply);
 129         assert(s);
 130
 131         r = session_get_idle_hint(s, &t);
 132         if (r < 0)
 133                 return r;
 134
 135         u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
 136
 137         return sd_bus_message_append(reply, "t", u);
 138 }
 139
 140 static int property_get_locked_hint(
 141                 sd_bus *bus,
 142                 const char *path,
 143                 const char *interface,
 144                 const char *property,
 145                 sd_bus_message *reply,
 146                 void *userdata,
 147                 sd_bus_error *error) {
 148
 149         Session *s = userdata;
 150
 151         assert(bus);
 152         assert(reply);
 153         assert(s);
 154
 155         return sd_bus_message_append(reply, "b", session_get_locked_hint(s) > 0);
 156 }
 157
 158 int bus_session_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 159         Session *s = userdata;
 160         int r;
 161
 162         assert(message);
 163         assert(s);
 164
 165         r = bus_verify_polkit_async(
 166                         message,
 167                         CAP_KILL,
 168                         "org.freedesktop.login1.manage",
 169                         NULL,
 170                         false,
 171                         s->user->user_record->uid,
 172                         &s->manager->polkit_registry,
 173                         error);
 174         if (r < 0)
 175                 return r;
 176         if (r == 0)
 177                 return 1; /* Will call us back */
 178
 179         r = session_stop(s, true);
 180         if (r < 0)
 181                 return r;
 182
 183         return sd_bus_reply_method_return(message, NULL);
 184 }
 185
 186 int bus_session_method_activate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 187         Session *s = userdata;
 188         int r;
 189
 190         assert(message);
 191         assert(s);
 192
 193         r = session_activate(s);
 194         if (r < 0)
 195                 return r;
 196
 197         return sd_bus_reply_method_return(message, NULL);
 198 }
 199
 200 int bus_session_method_lock(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 201         Session *s = userdata;
 202         int r;
 203
 204         assert(message);
 205         assert(s);
 206
 207         r = bus_verify_polkit_async(
 208                         message,
 209                         CAP_SYS_ADMIN,
 210                         "org.freedesktop.login1.lock-sessions",
 211                         NULL,
 212                         false,
 213                         s->user->user_record->uid,
 214                         &s->manager->polkit_registry,
 215                         error);
 216         if (r < 0)
 217                 return r;
 218         if (r == 0)
 219                 return 1; /* Will call us back */
 220
 221         r = session_send_lock(s, strstr(sd_bus_message_get_member(message), "Lock"));
 222         if (r < 0)
 223                 return r;
 224
 225         return sd_bus_reply_method_return(message, NULL);
 226 }
 227
 228 static int method_set_idle_hint(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 229         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 230         Session *s = userdata;
 231         uid_t uid;
 232         int r, b;
 233
 234         assert(message);
 235         assert(s);
 236
 237         r = sd_bus_message_read(message, "b", &b);
 238         if (r < 0)
 239                 return r;
 240
 241         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
 242         if (r < 0)
 243                 return r;
 244
 245         r = sd_bus_creds_get_euid(creds, &uid);
 246         if (r < 0)
 247                 return r;
 248
 249         if (uid != 0 && uid != s->user->user_record->uid)
 250                 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may set idle hint");
 251
 252         r = session_set_idle_hint(s, b);
 253         if (r == -ENOTTY)
 254                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Idle hint control is not supported on non-graphical sessions.");
 255         if (r < 0)
 256                 return r;
 257
 258         return sd_bus_reply_method_return(message, NULL);
 259 }
 260
 261 static int method_set_locked_hint(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 262         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 263         Session *s = userdata;
 264         uid_t uid;
 265         int r, b;
 266
 267         assert(message);
 268         assert(s);
 269
 270         r = sd_bus_message_read(message, "b", &b);
 271         if (r < 0)
 272                 return r;
 273
 274         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
 275         if (r < 0)
 276                 return r;
 277
 278         r = sd_bus_creds_get_euid(creds, &uid);
 279         if (r < 0)
 280                 return r;
 281
 282         if (uid != 0 && uid != s->user->user_record->uid)
 283                 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may set locked hint");
 284
 285         session_set_locked_hint(s, b);
 286
 287         return sd_bus_reply_method_return(message, NULL);
 288 }
 289
 290 int bus_session_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 291         Session *s = userdata;
 292         const char *swho;
 293         int32_t signo;
 294         KillWho who;
 295         int r;
 296
 297         assert(message);
 298         assert(s);
 299
 300         r = sd_bus_message_read(message, "si", &swho, &signo);
 301         if (r < 0)
 302                 return r;
 303
 304         if (isempty(swho))
 305                 who = KILL_ALL;
 306         else {
 307                 who = kill_who_from_string(swho);
 308                 if (who < 0)
 309                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
 310         }
 311
 312         if (!SIGNAL_VALID(signo))
 313                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
 314
 315         r = bus_verify_polkit_async(
 316                         message,
 317                         CAP_KILL,
 318                         "org.freedesktop.login1.manage",
 319                         NULL,
 320                         false,
 321                         s->user->user_record->uid,
 322                         &s->manager->polkit_registry,
 323                         error);
 324         if (r < 0)
 325                 return r;
 326         if (r == 0)
 327                 return 1; /* Will call us back */
 328
 329         r = session_kill(s, who, signo);
 330         if (r < 0)
 331                 return r;
 332
 333         return sd_bus_reply_method_return(message, NULL);
 334 }
 335
 336 static int method_take_control(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 337         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 338         Session *s = userdata;
 339         int r, force;
 340         uid_t uid;
 341
 342         assert(message);
 343         assert(s);
 344
 345         r = sd_bus_message_read(message, "b", &force);
 346         if (r < 0)
 347                 return r;
 348
 349         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
 350         if (r < 0)
 351                 return r;
 352
 353         r = sd_bus_creds_get_euid(creds, &uid);
 354         if (r < 0)
 355                 return r;
 356
 357         if (uid != 0 && (force || uid != s->user->user_record->uid))
 358                 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may take control");
 359
 360         r = session_set_controller(s, sd_bus_message_get_sender(message), force, true);
 361         if (r < 0)
 362                 return r;
 363
 364         return sd_bus_reply_method_return(message, NULL);
 365 }
 366
 367 static int method_release_control(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 368         Session *s = userdata;
 369
 370         assert(message);
 371         assert(s);
 372
 373         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
 374                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 375
 376         session_drop_controller(s);
 377
 378         return sd_bus_reply_method_return(message, NULL);
 379 }
 380
 381 static int method_take_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 382         Session *s = userdata;
 383         uint32_t major, minor;
 384         SessionDevice *sd;
 385         dev_t dev;
 386         int r;
 387
 388         assert(message);
 389         assert(s);
 390
 391         r = sd_bus_message_read(message, "uu", &major, &minor);
 392         if (r < 0)
 393                 return r;
 394
 395         if (!DEVICE_MAJOR_VALID(major) || !DEVICE_MINOR_VALID(minor))
 396                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Device major/minor is not valid.");
 397
 398         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
 399                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 400
 401         dev = makedev(major, minor);
 402         sd = hashmap_get(s->devices, &dev);
 403         if (sd)
 404                 /* We don't allow retrieving a device multiple times.
 405                  * The related ReleaseDevice call is not ref-counted.
 406                  * The caller should use dup() if it requires more
 407                  * than one fd (it would be functionally
 408                  * equivalent). */
 409                 return sd_bus_error_setf(error, BUS_ERROR_DEVICE_IS_TAKEN, "Device already taken");
 410
 411         r = session_device_new(s, dev, true, &sd);
 412         if (r < 0)
 413                 return r;
 414
 415         r = session_device_save(sd);
 416         if (r < 0)
 417                 goto error;
 418
 419         r = sd_bus_reply_method_return(message, "hb", sd->fd, !sd->active);
 420         if (r < 0)
 421                 goto error;
 422
 423         session_save(s);
 424         return 1;
 425
 426 error:
 427         session_device_free(sd);
 428         return r;
 429 }
 430
 431 static int method_release_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 432         Session *s = userdata;
 433         uint32_t major, minor;
 434         SessionDevice *sd;
 435         dev_t dev;
 436         int r;
 437
 438         assert(message);
 439         assert(s);
 440
 441         r = sd_bus_message_read(message, "uu", &major, &minor);
 442         if (r < 0)
 443                 return r;
 444
 445         if (!DEVICE_MAJOR_VALID(major) || !DEVICE_MINOR_VALID(minor))
 446                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Device major/minor is not valid.");
 447
 448         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
 449                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 450
 451         dev = makedev(major, minor);
 452         sd = hashmap_get(s->devices, &dev);
 453         if (!sd)
 454                 return sd_bus_error_setf(error, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
 455
 456         session_device_free(sd);
 457         session_save(s);
 458
 459         return sd_bus_reply_method_return(message, NULL);
 460 }
 461
 462 static int method_pause_device_complete(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 463         Session *s = userdata;
 464         uint32_t major, minor;
 465         SessionDevice *sd;
 466         dev_t dev;
 467         int r;
 468
 469         assert(message);
 470         assert(s);
 471
 472         r = sd_bus_message_read(message, "uu", &major, &minor);
 473         if (r < 0)
 474                 return r;
 475
 476         if (!DEVICE_MAJOR_VALID(major) || !DEVICE_MINOR_VALID(minor))
 477                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Device major/minor is not valid.");
 478
 479         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
 480                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
 481
 482         dev = makedev(major, minor);
 483         sd = hashmap_get(s->devices, &dev);
 484         if (!sd)
 485                 return sd_bus_error_setf(error, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
 486
 487         session_device_complete_pause(sd);
 488
 489         return sd_bus_reply_method_return(message, NULL);
 490 }
 491
 492 static int method_set_brightness(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 493         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 494         _cleanup_(sd_device_unrefp) sd_device *d = NULL;
 495         const char *subsystem, *name, *seat;
 496         Session *s = userdata;
 497         uint32_t brightness;
 498         uid_t uid;
 499         int r;
 500
 501         assert(message);
 502         assert(s);
 503
 504         r = sd_bus_message_read(message, "ssu", &subsystem, &name, &brightness);
 505         if (r < 0)
 506                 return r;
 507
 508         if (!STR_IN_SET(subsystem, "backlight", "leds"))
 509                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Subsystem type %s not supported, must be one of 'backlight' or 'leds'.", subsystem);
 510         if (!filename_is_valid(name))
 511                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Not a valid device name %s, refusing.", name);
 512
 513         if (!s->seat)
 514                 return sd_bus_error_setf(error, BUS_ERROR_NOT_YOUR_DEVICE, "Your session has no seat, refusing.");
 515         if (s->seat->active != s)
 516                 return sd_bus_error_setf(error, BUS_ERROR_NOT_YOUR_DEVICE, "Session is not in foreground, refusing.");
 517
 518         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
 519         if (r < 0)
 520                 return r;
 521
 522         r = sd_bus_creds_get_euid(creds, &uid);
 523         if (r < 0)
 524                 return r;
 525
 526         if (uid != 0 && uid != s->user->user_record->uid)
 527                 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may change brightness.");
 528
 529         r = sd_device_new_from_subsystem_sysname(&d, subsystem, name);
 530         if (r < 0)
 531                 return sd_bus_error_set_errnof(error, r, "Failed to open device %s:%s: %m", subsystem, name);
 532
 533         if (sd_device_get_property_value(d, "ID_SEAT", &seat) >= 0 && !streq_ptr(seat, s->seat->id))
 534                 return sd_bus_error_setf(error, BUS_ERROR_NOT_YOUR_DEVICE, "Device %s:%s does not belong to your seat %s, refusing.", subsystem, name, s->seat->id);
 535
 536         r = manager_write_brightness(s->manager, d, brightness, message);
 537         if (r < 0)
 538                 return r;
 539
 540         return 1;
 541 }
 542
 543 const sd_bus_vtable session_vtable[] = {
 544         SD_BUS_VTABLE_START(0),
 545
 546         SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Session, id), SD_BUS_VTABLE_PROPERTY_CONST),
 547         SD_BUS_PROPERTY("User", "(uo)", property_get_user, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 548         SD_BUS_PROPERTY("Name", "s", property_get_name, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 549         BUS_PROPERTY_DUAL_TIMESTAMP("Timestamp", offsetof(Session, timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
 550         SD_BUS_PROPERTY("VTNr", "u", NULL, offsetof(Session, vtnr), SD_BUS_VTABLE_PROPERTY_CONST),
 551         SD_BUS_PROPERTY("Seat", "(so)", property_get_seat, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 552         SD_BUS_PROPERTY("TTY", "s", NULL, offsetof(Session, tty), SD_BUS_VTABLE_PROPERTY_CONST),
 553         SD_BUS_PROPERTY("Display", "s", NULL, offsetof(Session, display), SD_BUS_VTABLE_PROPERTY_CONST),
 554         SD_BUS_PROPERTY("Remote", "b", bus_property_get_bool, offsetof(Session, remote), SD_BUS_VTABLE_PROPERTY_CONST),
 555         SD_BUS_PROPERTY("RemoteHost", "s", NULL, offsetof(Session, remote_host), SD_BUS_VTABLE_PROPERTY_CONST),
 556         SD_BUS_PROPERTY("RemoteUser", "s", NULL, offsetof(Session, remote_user), SD_BUS_VTABLE_PROPERTY_CONST),
 557         SD_BUS_PROPERTY("Service", "s", NULL, offsetof(Session, service), SD_BUS_VTABLE_PROPERTY_CONST),
 558         SD_BUS_PROPERTY("Desktop", "s", NULL, offsetof(Session, desktop), SD_BUS_VTABLE_PROPERTY_CONST),
 559         SD_BUS_PROPERTY("Scope", "s", NULL, offsetof(Session, scope), SD_BUS_VTABLE_PROPERTY_CONST),
 560         SD_BUS_PROPERTY("Leader", "u", bus_property_get_pid, offsetof(Session, leader), SD_BUS_VTABLE_PROPERTY_CONST),
 561         SD_BUS_PROPERTY("Audit", "u", NULL, offsetof(Session, audit_id), SD_BUS_VTABLE_PROPERTY_CONST),
 562         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Session, type), SD_BUS_VTABLE_PROPERTY_CONST),
 563         SD_BUS_PROPERTY("Class", "s", property_get_class, offsetof(Session, class), SD_BUS_VTABLE_PROPERTY_CONST),
 564         SD_BUS_PROPERTY("Active", "b", property_get_active, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 565         SD_BUS_PROPERTY("State", "s", property_get_state, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 566         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 567         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 568         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 569         SD_BUS_PROPERTY("LockedHint", "b", property_get_locked_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 570
 571         SD_BUS_METHOD("Terminate", NULL, NULL, bus_session_method_terminate, SD_BUS_VTABLE_UNPRIVILEGED),
 572         SD_BUS_METHOD("Activate", NULL, NULL, bus_session_method_activate, SD_BUS_VTABLE_UNPRIVILEGED),
 573         SD_BUS_METHOD("Lock", NULL, NULL, bus_session_method_lock, SD_BUS_VTABLE_UNPRIVILEGED),
 574         SD_BUS_METHOD("Unlock", NULL, NULL, bus_session_method_lock, SD_BUS_VTABLE_UNPRIVILEGED),
 575         SD_BUS_METHOD("SetIdleHint", "b", NULL, method_set_idle_hint, SD_BUS_VTABLE_UNPRIVILEGED),
 576         SD_BUS_METHOD("SetLockedHint", "b", NULL, method_set_locked_hint, SD_BUS_VTABLE_UNPRIVILEGED),
 577         SD_BUS_METHOD("Kill", "si", NULL, bus_session_method_kill, SD_BUS_VTABLE_UNPRIVILEGED),
 578         SD_BUS_METHOD("TakeControl", "b", NULL, method_take_control, SD_BUS_VTABLE_UNPRIVILEGED),
 579         SD_BUS_METHOD("ReleaseControl", NULL, NULL, method_release_control, SD_BUS_VTABLE_UNPRIVILEGED),
 580         SD_BUS_METHOD("TakeDevice", "uu", "hb", method_take_device, SD_BUS_VTABLE_UNPRIVILEGED),
 581         SD_BUS_METHOD("ReleaseDevice", "uu", NULL, method_release_device, SD_BUS_VTABLE_UNPRIVILEGED),
 582         SD_BUS_METHOD("PauseDeviceComplete", "uu", NULL, method_pause_device_complete, SD_BUS_VTABLE_UNPRIVILEGED),
 583         SD_BUS_METHOD("SetBrightness", "ssu", NULL, method_set_brightness, SD_BUS_VTABLE_UNPRIVILEGED),
 584
 585         SD_BUS_SIGNAL("PauseDevice", "uus", 0),
 586         SD_BUS_SIGNAL("ResumeDevice", "uuh", 0),
 587         SD_BUS_SIGNAL("Lock", NULL, 0),
 588         SD_BUS_SIGNAL("Unlock", NULL, 0),
 589
 590         SD_BUS_VTABLE_END
 591 };
 592
 593 int session_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
 594         _cleanup_free_ char *e = NULL;
 595         sd_bus_message *message;
 596         Manager *m = userdata;
 597         Session *session;
 598         const char *p;
 599         int r;
 600
 601         assert(bus);
 602         assert(path);
 603         assert(interface);
 604         assert(found);
 605         assert(m);
 606
 607         p = startswith(path, "/org/freedesktop/login1/session/");
 608         if (!p)
 609                 return 0;
 610
 611         e = bus_label_unescape(p);
 612         if (!e)
 613                 return -ENOMEM;
 614
 615         message = sd_bus_get_current_message(bus);
 616
 617         r = manager_get_session_from_creds(m, message, e, error, &session);
 618         if (r == -ENXIO) {
 619                 sd_bus_error_free(error);
 620                 return 0;
 621         }
 622         if (r < 0)
 623                 return r;
 624
 625         *found = session;
 626         return 1;
 627 }
 628
 629 char *session_bus_path(Session *s) {
 630         _cleanup_free_ char *t = NULL;
 631
 632         assert(s);
 633
 634         t = bus_label_escape(s->id);
 635         if (!t)
 636                 return NULL;
 637
 638         return strjoin("/org/freedesktop/login1/session/", t);
 639 }
 640
 641 int session_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
 642         _cleanup_strv_free_ char **l = NULL;
 643         sd_bus_message *message;
 644         Manager *m = userdata;
 645         Session *session;
 646         Iterator i;
 647         int r;
 648
 649         assert(bus);
 650         assert(path);
 651         assert(nodes);
 652
 653         HASHMAP_FOREACH(session, m->sessions, i) {
 654                 char *p;
 655
 656                 p = session_bus_path(session);
 657                 if (!p)
 658                         return -ENOMEM;
 659
 660                 r = strv_consume(&l, p);
 661                 if (r < 0)
 662                         return r;
 663         }
 664
 665         message = sd_bus_get_current_message(bus);
 666         if (message) {
 667                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 668
 669                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
 670                 if (r >= 0) {
 671                         bool may_auto = false;
 672                         const char *name;
 673
 674                         r = sd_bus_creds_get_session(creds, &name);
 675                         if (r >= 0) {
 676                                 session = hashmap_get(m->sessions, name);
 677                                 if (session) {
 678                                         r = strv_extend(&l, "/org/freedesktop/login1/session/self");
 679                                         if (r < 0)
 680                                                 return r;
 681
 682                                         may_auto = true;
 683                                 }
 684                         }
 685
 686                         if (!may_auto) {
 687                                 uid_t uid;
 688
 689                                 r = sd_bus_creds_get_owner_uid(creds, &uid);
 690                                 if (r >= 0) {
 691                                         User *user;
 692
 693                                         user = hashmap_get(m->users, UID_TO_PTR(uid));
 694                                         may_auto = user && user->display;
 695                                 }
 696                         }
 697
 698                         if (may_auto) {
 699                                 r = strv_extend(&l, "/org/freedesktop/login1/session/auto");
 700                                 if (r < 0)
 701                                         return r;
 702                         }
 703                 }
 704         }
 705
 706         *nodes = TAKE_PTR(l);
 707         return 1;
 708 }
 709
 710 int session_send_signal(Session *s, bool new_session) {
 711         _cleanup_free_ char *p = NULL;
 712
 713         assert(s);
 714
 715         p = session_bus_path(s);
 716         if (!p)
 717                 return -ENOMEM;
 718
 719         return sd_bus_emit_signal(
 720                         s->manager->bus,
 721                         "/org/freedesktop/login1",
 722                         "org.freedesktop.login1.Manager",
 723                         new_session ? "SessionNew" : "SessionRemoved",
 724                         "so", s->id, p);
 725 }
 726
 727 int session_send_changed(Session *s, const char *properties, ...) {
 728         _cleanup_free_ char *p = NULL;
 729         char **l;
 730
 731         assert(s);
 732
 733         if (!s->started)
 734                 return 0;
 735
 736         p = session_bus_path(s);
 737         if (!p)
 738                 return -ENOMEM;
 739
 740         l = strv_from_stdarg_alloca(properties);
 741
 742         return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Session", l);
 743 }
 744
 745 int session_send_lock(Session *s, bool lock) {
 746         _cleanup_free_ char *p = NULL;
 747
 748         assert(s);
 749
 750         p = session_bus_path(s);
 751         if (!p)
 752                 return -ENOMEM;
 753
 754         return sd_bus_emit_signal(
 755                         s->manager->bus,
 756                         p,
 757                         "org.freedesktop.login1.Session",
 758                         lock ? "Lock" : "Unlock",
 759                         NULL);
 760 }
 761
 762 int session_send_lock_all(Manager *m, bool lock) {
 763         Session *session;
 764         Iterator i;
 765         int r = 0;
 766
 767         assert(m);
 768
 769         HASHMAP_FOREACH(session, m->sessions, i) {
 770                 int k;
 771
 772                 k = session_send_lock(session, lock);
 773                 if (k < 0)
 774                         r = k;
 775         }
 776
 777         return r;
 778 }
 779
 780 static bool session_ready(Session *s) {
 781         assert(s);
 782
 783         /* Returns true when the session is ready, i.e. all jobs we enqueued for it are done (regardless if successful or not) */
 784
 785         return !s->scope_job &&
 786                 !s->user->service_job;
 787 }
 788
 789 int session_send_create_reply(Session *s, sd_bus_error *error) {
 790         _cleanup_(sd_bus_message_unrefp) sd_bus_message *c = NULL;
 791         _cleanup_close_ int fifo_fd = -1;
 792         _cleanup_free_ char *p = NULL;
 793
 794         assert(s);
 795
 796         /* This is called after the session scope and the user service were successfully created, and finishes where
 797          * bus_manager_create_session() left off. */
 798
 799         if (!s->create_message)
 800                 return 0;
 801
 802         if (!sd_bus_error_is_set(error) && !session_ready(s))
 803                 return 0;
 804
 805         c = TAKE_PTR(s->create_message);
 806         if (error)
 807                 return sd_bus_reply_method_error(c, error);
 808
 809         fifo_fd = session_create_fifo(s);
 810         if (fifo_fd < 0)
 811                 return fifo_fd;
 812
 813         /* Update the session state file before we notify the client about the result. */
 814         session_save(s);
 815
 816         p = session_bus_path(s);
 817         if (!p)
 818                 return -ENOMEM;
 819
 820         log_debug("Sending reply about created session: "
 821                   "id=%s object_path=%s uid=%u runtime_path=%s "
 822                   "session_fd=%d seat=%s vtnr=%u",
 823                   s->id,
 824                   p,
 825                   (uint32_t) s->user->user_record->uid,
 826                   s->user->runtime_path,
 827                   fifo_fd,
 828                   s->seat ? s->seat->id : "",
 829                   (uint32_t) s->vtnr);
 830
 831         return sd_bus_reply_method_return(
 832                         c, "soshusub",
 833                         s->id,
 834                         p,
 835                         s->user->runtime_path,
 836                         fifo_fd,
 837                         (uint32_t) s->user->user_record->uid,
 838                         s->seat ? s->seat->id : "",
 839                         (uint32_t) s->vtnr,
 840                         false);
 841 }