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