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