chiark / gitweb /
563153e2d92b64644f35e3c587cbd4da43a71bd3
[elogind.git] / src / login / logind-session-dbus.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2011 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <string.h>
24
25 #include "util.h"
26 #include "strv.h"
27 #include "bus-util.h"
28 #include "bus-common-errors.h"
29 #include "bus-label.h"
30
31 #include "logind.h"
32 #include "logind-session.h"
33 #include "logind-session-device.h"
34
35 static int property_get_user(
36                 sd_bus *bus,
37                 const char *path,
38                 const char *interface,
39                 const char *property,
40                 sd_bus_message *reply,
41                 void *userdata,
42                 sd_bus_error *error) {
43
44         _cleanup_free_ char *p = NULL;
45         Session *s = userdata;
46
47         assert(bus);
48         assert(reply);
49         assert(s);
50
51         p = user_bus_path(s->user);
52         if (!p)
53                 return -ENOMEM;
54
55         return sd_bus_message_append(reply, "(uo)", (uint32_t) s->user->uid, p);
56 }
57
58 static int property_get_name(
59                 sd_bus *bus,
60                 const char *path,
61                 const char *interface,
62                 const char *property,
63                 sd_bus_message *reply,
64                 void *userdata,
65                 sd_bus_error *error) {
66
67         Session *s = userdata;
68
69         assert(bus);
70         assert(reply);
71         assert(s);
72
73         return sd_bus_message_append(reply, "s", s->user->name);
74 }
75
76 static int property_get_seat(
77                 sd_bus *bus,
78                 const char *path,
79                 const char *interface,
80                 const char *property,
81                 sd_bus_message *reply,
82                 void *userdata,
83                 sd_bus_error *error) {
84
85         _cleanup_free_ char *p = NULL;
86         Session *s = userdata;
87
88         assert(bus);
89         assert(reply);
90         assert(s);
91
92         p = s->seat ? seat_bus_path(s->seat) : strdup("/");
93         if (!p)
94                 return -ENOMEM;
95
96         return sd_bus_message_append(reply, "(so)", s->seat ? s->seat->id : "", p);
97 }
98
99 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, session_type, SessionType);
100 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_class, session_class, SessionClass);
101
102 static int property_get_active(
103                 sd_bus *bus,
104                 const char *path,
105                 const char *interface,
106                 const char *property,
107                 sd_bus_message *reply,
108                 void *userdata,
109                 sd_bus_error *error) {
110
111         Session *s = userdata;
112
113         assert(bus);
114         assert(reply);
115         assert(s);
116
117         return sd_bus_message_append(reply, "b", session_is_active(s));
118 }
119
120 static int property_get_state(
121                 sd_bus *bus,
122                 const char *path,
123                 const char *interface,
124                 const char *property,
125                 sd_bus_message *reply,
126                 void *userdata,
127                 sd_bus_error *error) {
128
129         Session *s = userdata;
130
131         assert(bus);
132         assert(reply);
133         assert(s);
134
135         return sd_bus_message_append(reply, "s", session_state_to_string(session_get_state(s)));
136 }
137
138 static int property_get_idle_hint(
139                 sd_bus *bus,
140                 const char *path,
141                 const char *interface,
142                 const char *property,
143                 sd_bus_message *reply,
144                 void *userdata,
145                 sd_bus_error *error) {
146
147         Session *s = userdata;
148
149         assert(bus);
150         assert(reply);
151         assert(s);
152
153         return sd_bus_message_append(reply, "b", session_get_idle_hint(s, NULL) > 0);
154 }
155
156 static int property_get_idle_since_hint(
157                 sd_bus *bus,
158                 const char *path,
159                 const char *interface,
160                 const char *property,
161                 sd_bus_message *reply,
162                 void *userdata,
163                 sd_bus_error *error) {
164
165         Session *s = userdata;
166         dual_timestamp t = DUAL_TIMESTAMP_NULL;
167         uint64_t u;
168         int r;
169
170         assert(bus);
171         assert(reply);
172         assert(s);
173
174         r = session_get_idle_hint(s, &t);
175         if (r < 0)
176                 return r;
177
178         u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
179
180         return sd_bus_message_append(reply, "t", u);
181 }
182
183 int bus_session_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
184         Session *s = userdata;
185         int r;
186
187         assert(message);
188         assert(s);
189
190         r = bus_verify_polkit_async(
191                         message,
192                         CAP_KILL,
193                         "org.freedesktop.login1.manage",
194                         false,
195                         s->user->uid,
196                         &s->manager->polkit_registry,
197                         error);
198         if (r < 0)
199                 return r;
200         if (r == 0)
201                 return 1; /* Will call us back */
202
203         r = session_stop(s, true);
204         if (r < 0)
205                 return r;
206
207         return sd_bus_reply_method_return(message, NULL);
208 }
209
210 int bus_session_method_activate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
211         Session *s = userdata;
212         int r;
213
214         assert(message);
215         assert(s);
216
217         r = session_activate(s);
218         if (r < 0)
219                 return r;
220
221         return sd_bus_reply_method_return(message, NULL);
222 }
223
224 int bus_session_method_lock(sd_bus_message *message, void *userdata, sd_bus_error *error) {
225         Session *s = userdata;
226         int r;
227
228         assert(message);
229         assert(s);
230
231         r = bus_verify_polkit_async(
232                         message,
233                         CAP_SYS_ADMIN,
234                         "org.freedesktop.login1.lock-sessions",
235                         false,
236                         s->user->uid,
237                         &s->manager->polkit_registry,
238                         error);
239         if (r < 0)
240                 return r;
241         if (r == 0)
242                 return 1; /* Will call us back */
243
244         r = session_send_lock(s, strstr(sd_bus_message_get_member(message), "Lock"));
245         if (r < 0)
246                 return r;
247
248         return sd_bus_reply_method_return(message, NULL);
249 }
250
251 static int method_set_idle_hint(sd_bus_message *message, void *userdata, sd_bus_error *error) {
252         _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
253         Session *s = userdata;
254         uid_t uid;
255         int r, b;
256
257         assert(message);
258         assert(s);
259
260         r = sd_bus_message_read(message, "b", &b);
261         if (r < 0)
262                 return r;
263
264         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
265         if (r < 0)
266                 return r;
267
268         r = sd_bus_creds_get_euid(creds, &uid);
269         if (r < 0)
270                 return r;
271
272         if (uid != 0 && uid != s->user->uid)
273                 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may set idle hint");
274
275         session_set_idle_hint(s, b);
276
277         return sd_bus_reply_method_return(message, NULL);
278 }
279
280 int bus_session_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
281         Session *s = userdata;
282         const char *swho;
283         int32_t signo;
284         KillWho who;
285         int r;
286
287         assert(message);
288         assert(s);
289
290         r = sd_bus_message_read(message, "si", &swho, &signo);
291         if (r < 0)
292                 return r;
293
294         if (isempty(swho))
295                 who = KILL_ALL;
296         else {
297                 who = kill_who_from_string(swho);
298                 if (who < 0)
299                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
300         }
301
302         if (signo <= 0 || signo >= _NSIG)
303                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
304
305         r = bus_verify_polkit_async(
306                         message,
307                         CAP_KILL,
308                         "org.freedesktop.login1.manage",
309                         false,
310                         s->user->uid,
311                         &s->manager->polkit_registry,
312                         error);
313         if (r < 0)
314                 return r;
315         if (r == 0)
316                 return 1; /* Will call us back */
317
318         r = session_kill(s, who, signo);
319         if (r < 0)
320                 return r;
321
322         return sd_bus_reply_method_return(message, NULL);
323 }
324
325 static int method_take_control(sd_bus_message *message, void *userdata, sd_bus_error *error) {
326         _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
327         Session *s = userdata;
328         int r, force;
329         uid_t uid;
330
331         assert(message);
332         assert(s);
333
334         r = sd_bus_message_read(message, "b", &force);
335         if (r < 0)
336                 return r;
337
338         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
339         if (r < 0)
340                 return r;
341
342         r = sd_bus_creds_get_euid(creds, &uid);
343         if (r < 0)
344                 return r;
345
346         if (uid != 0 && (force || uid != s->user->uid))
347                 return sd_bus_error_setf(error, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may take control");
348
349         r = session_set_controller(s, sd_bus_message_get_sender(message), force);
350         if (r < 0)
351                 return r;
352
353         return sd_bus_reply_method_return(message, NULL);
354 }
355
356 static int method_release_control(sd_bus_message *message, void *userdata, sd_bus_error *error) {
357         Session *s = userdata;
358
359         assert(message);
360         assert(s);
361
362         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
363                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
364
365         session_drop_controller(s);
366
367         return sd_bus_reply_method_return(message, NULL);
368 }
369
370 static int method_take_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
371         Session *s = userdata;
372         uint32_t major, minor;
373         SessionDevice *sd;
374         dev_t dev;
375         int r;
376
377         assert(message);
378         assert(s);
379
380         r = sd_bus_message_read(message, "uu", &major, &minor);
381         if (r < 0)
382                 return r;
383
384         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
385                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
386
387         dev = makedev(major, minor);
388         sd = hashmap_get(s->devices, &dev);
389         if (sd)
390                 /* We don't allow retrieving a device multiple times.
391                  * The related ReleaseDevice call is not ref-counted.
392                  * The caller should use dup() if it requires more
393                  * than one fd (it would be functionally
394                  * equivalent). */
395                 return sd_bus_error_setf(error, BUS_ERROR_DEVICE_IS_TAKEN, "Device already taken");
396
397         r = session_device_new(s, dev, &sd);
398         if (r < 0)
399                 return r;
400
401         r = sd_bus_reply_method_return(message, "hb", sd->fd, !sd->active);
402         if (r < 0)
403                 session_device_free(sd);
404
405         return r;
406 }
407
408 static int method_release_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
409         Session *s = userdata;
410         uint32_t major, minor;
411         SessionDevice *sd;
412         dev_t dev;
413         int r;
414
415         assert(message);
416         assert(s);
417
418         r = sd_bus_message_read(message, "uu", &major, &minor);
419         if (r < 0)
420                 return r;
421
422         if (!session_is_controller(s, sd_bus_message_get_sender(message)))
423                 return sd_bus_error_setf(error, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
424
425         dev = makedev(major, minor);
426         sd = hashmap_get(s->devices, &dev);
427         if (!sd)
428                 return sd_bus_error_setf(error, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
429
430         session_device_free(sd);
431         return sd_bus_reply_method_return(message, NULL);
432 }
433
434 static int method_pause_device_complete(sd_bus_message *message, void *userdata, sd_bus_error *error) {
435         Session *s = userdata;
436         uint32_t major, minor;
437         SessionDevice *sd;
438         dev_t dev;
439         int r;
440
441         assert(message);
442         assert(s);
443
444         r = sd_bus_message_read(message, "uu", &major, &minor);
445         if (r < 0)
446                 return r;
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_complete_pause(sd);
457
458         return sd_bus_reply_method_return(message, NULL);
459 }
460
461 const sd_bus_vtable session_vtable[] = {
462         SD_BUS_VTABLE_START(0),
463
464         SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Session, id), SD_BUS_VTABLE_PROPERTY_CONST),
465         SD_BUS_PROPERTY("User", "(uo)", property_get_user, 0, SD_BUS_VTABLE_PROPERTY_CONST),
466         SD_BUS_PROPERTY("Name", "s", property_get_name, 0, SD_BUS_VTABLE_PROPERTY_CONST),
467         BUS_PROPERTY_DUAL_TIMESTAMP("Timestamp", offsetof(Session, timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
468         SD_BUS_PROPERTY("VTNr", "u", NULL, offsetof(Session, vtnr), SD_BUS_VTABLE_PROPERTY_CONST),
469         SD_BUS_PROPERTY("Seat", "(so)", property_get_seat, 0, SD_BUS_VTABLE_PROPERTY_CONST),
470         SD_BUS_PROPERTY("TTY", "s", NULL, offsetof(Session, tty), SD_BUS_VTABLE_PROPERTY_CONST),
471         SD_BUS_PROPERTY("Display", "s", NULL, offsetof(Session, display), SD_BUS_VTABLE_PROPERTY_CONST),
472         SD_BUS_PROPERTY("Remote", "b", bus_property_get_bool, offsetof(Session, remote), SD_BUS_VTABLE_PROPERTY_CONST),
473         SD_BUS_PROPERTY("RemoteHost", "s", NULL, offsetof(Session, remote_host), SD_BUS_VTABLE_PROPERTY_CONST),
474         SD_BUS_PROPERTY("RemoteUser", "s", NULL, offsetof(Session, remote_user), SD_BUS_VTABLE_PROPERTY_CONST),
475         SD_BUS_PROPERTY("Service", "s", NULL, offsetof(Session, service), SD_BUS_VTABLE_PROPERTY_CONST),
476         SD_BUS_PROPERTY("Desktop", "s", NULL, offsetof(Session, desktop), SD_BUS_VTABLE_PROPERTY_CONST),
477         SD_BUS_PROPERTY("Scope", "s", NULL, offsetof(Session, scope), SD_BUS_VTABLE_PROPERTY_CONST),
478         SD_BUS_PROPERTY("Leader", "u", bus_property_get_pid, offsetof(Session, leader), SD_BUS_VTABLE_PROPERTY_CONST),
479         SD_BUS_PROPERTY("Audit", "u", NULL, offsetof(Session, audit_id), SD_BUS_VTABLE_PROPERTY_CONST),
480         SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Session, type), SD_BUS_VTABLE_PROPERTY_CONST),
481         SD_BUS_PROPERTY("Class", "s", property_get_class, offsetof(Session, class), SD_BUS_VTABLE_PROPERTY_CONST),
482         SD_BUS_PROPERTY("Active", "b", property_get_active, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
483         SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
484         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
485         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
486         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
487
488         SD_BUS_METHOD("Terminate", NULL, NULL, bus_session_method_terminate, SD_BUS_VTABLE_UNPRIVILEGED),
489         SD_BUS_METHOD("Activate", NULL, NULL, bus_session_method_activate, SD_BUS_VTABLE_UNPRIVILEGED),
490         SD_BUS_METHOD("Lock", NULL, NULL, bus_session_method_lock, SD_BUS_VTABLE_UNPRIVILEGED),
491         SD_BUS_METHOD("Unlock", NULL, NULL, bus_session_method_lock, SD_BUS_VTABLE_UNPRIVILEGED),
492         SD_BUS_METHOD("SetIdleHint", "b", NULL, method_set_idle_hint, SD_BUS_VTABLE_UNPRIVILEGED),
493         SD_BUS_METHOD("Kill", "si", NULL, bus_session_method_kill, SD_BUS_VTABLE_UNPRIVILEGED),
494         SD_BUS_METHOD("TakeControl", "b", NULL, method_take_control, SD_BUS_VTABLE_UNPRIVILEGED),
495         SD_BUS_METHOD("ReleaseControl", NULL, NULL, method_release_control, SD_BUS_VTABLE_UNPRIVILEGED),
496         SD_BUS_METHOD("TakeDevice", "uu", "hb", method_take_device, SD_BUS_VTABLE_UNPRIVILEGED),
497         SD_BUS_METHOD("ReleaseDevice", "uu", NULL, method_release_device, SD_BUS_VTABLE_UNPRIVILEGED),
498         SD_BUS_METHOD("PauseDeviceComplete", "uu", NULL, method_pause_device_complete, SD_BUS_VTABLE_UNPRIVILEGED),
499
500         SD_BUS_SIGNAL("PauseDevice", "uus", 0),
501         SD_BUS_SIGNAL("ResumeDevice", "uuh", 0),
502         SD_BUS_SIGNAL("Lock", NULL, 0),
503         SD_BUS_SIGNAL("Unlock", NULL, 0),
504
505         SD_BUS_VTABLE_END
506 };
507
508 int session_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
509         Manager *m = userdata;
510         Session *session;
511         int r;
512
513         assert(bus);
514         assert(path);
515         assert(interface);
516         assert(found);
517         assert(m);
518
519         if (streq(path, "/org/freedesktop/login1/session/self")) {
520                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
521                 sd_bus_message *message;
522                 const char *name;
523
524                 message = sd_bus_get_current_message(bus);
525                 if (!message)
526                         return 0;
527
528                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_AUGMENT, &creds);
529                 if (r < 0)
530                         return r;
531
532                 r = sd_bus_creds_get_session(creds, &name);
533                 if (r < 0)
534                         return r;
535
536                 session = hashmap_get(m->sessions, name);
537         } else {
538                 _cleanup_free_ char *e = NULL;
539                 const char *p;
540
541                 p = startswith(path, "/org/freedesktop/login1/session/");
542                 if (!p)
543                         return 0;
544
545                 e = bus_label_unescape(p);
546                 if (!e)
547                         return -ENOMEM;
548
549                 session = hashmap_get(m->sessions, e);
550         }
551
552         if (!session)
553                 return 0;
554
555         *found = session;
556         return 1;
557 }
558
559 char *session_bus_path(Session *s) {
560         _cleanup_free_ char *t = NULL;
561
562         assert(s);
563
564         t = bus_label_escape(s->id);
565         if (!t)
566                 return NULL;
567
568         return strappend("/org/freedesktop/login1/session/", t);
569 }
570
571 int session_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
572         _cleanup_strv_free_ char **l = NULL;
573         sd_bus_message *message;
574         Manager *m = userdata;
575         Session *session;
576         Iterator i;
577         int r;
578
579         assert(bus);
580         assert(path);
581         assert(nodes);
582
583         HASHMAP_FOREACH(session, m->sessions, i) {
584                 char *p;
585
586                 p = session_bus_path(session);
587                 if (!p)
588                         return -ENOMEM;
589
590                 r = strv_consume(&l, p);
591                 if (r < 0)
592                         return r;
593         }
594
595         message = sd_bus_get_current_message(bus);
596         if (message) {
597                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
598                 const char *name;
599
600                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_AUGMENT, &creds);
601                 if (r >= 0) {
602                         r = sd_bus_creds_get_session(creds, &name);
603                         if (r >= 0) {
604                                 session = hashmap_get(m->sessions, name);
605                                 if (session) {
606                                         r = strv_extend(&l, "/org/freedesktop/login1/session/self");
607                                         if (r < 0)
608                                                 return r;
609                                 }
610                         }
611                 }
612         }
613
614         *nodes = l;
615         l = NULL;
616
617         return 1;
618 }
619
620 int session_send_signal(Session *s, bool new_session) {
621         _cleanup_free_ char *p = NULL;
622
623         assert(s);
624
625         p = session_bus_path(s);
626         if (!p)
627                 return -ENOMEM;
628
629         return sd_bus_emit_signal(
630                         s->manager->bus,
631                         "/org/freedesktop/login1",
632                         "org.freedesktop.login1.Manager",
633                         new_session ? "SessionNew" : "SessionRemoved",
634                         "so", s->id, p);
635 }
636
637 int session_send_changed(Session *s, const char *properties, ...) {
638         _cleanup_free_ char *p = NULL;
639         char **l;
640
641         assert(s);
642
643         if (!s->started)
644                 return 0;
645
646         p = session_bus_path(s);
647         if (!p)
648                 return -ENOMEM;
649
650         l = strv_from_stdarg_alloca(properties);
651
652         return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Session", l);
653 }
654
655 int session_send_lock(Session *s, bool lock) {
656         _cleanup_free_ char *p = NULL;
657
658         assert(s);
659
660         p = session_bus_path(s);
661         if (!p)
662                 return -ENOMEM;
663
664         return sd_bus_emit_signal(
665                         s->manager->bus,
666                         p,
667                         "org.freedesktop.login1.Session",
668                         lock ? "Lock" : "Unlock",
669                         NULL);
670 }
671
672 int session_send_lock_all(Manager *m, bool lock) {
673         Session *session;
674         Iterator i;
675         int r = 0;
676
677         assert(m);
678
679         HASHMAP_FOREACH(session, m->sessions, i) {
680                 int k;
681
682                 k = session_send_lock(session, lock);
683                 if (k < 0)
684                         r = k;
685         }
686
687         return r;
688 }
689
690 int session_send_create_reply(Session *s, sd_bus_error *error) {
691         _cleanup_bus_message_unref_ sd_bus_message *c = NULL;
692         _cleanup_close_ int fifo_fd = -1;
693         _cleanup_free_ char *p = NULL;
694
695         assert(s);
696
697         /* This is called after the session scope and the user service
698          * were successfully created, and finishes where
699          * bus_manager_create_session() left off. */
700
701         if (!s->create_message)
702                 return 0;
703
704         if (!sd_bus_error_is_set(error) && (s->scope_job || s->user->service_job))
705                 return 0;
706
707         c = s->create_message;
708         s->create_message = NULL;
709
710         if (error)
711                 return sd_bus_reply_method_error(c, error);
712
713         fifo_fd = session_create_fifo(s);
714         if (fifo_fd < 0)
715                 return fifo_fd;
716
717         /* Update the session state file before we notify the client
718          * about the result. */
719         session_save(s);
720
721         p = session_bus_path(s);
722         if (!p)
723                 return -ENOMEM;
724
725         log_debug("Sending reply about created session: "
726                   "id=%s object_path=%s uid=%u runtime_path=%s "
727                   "session_fd=%d seat=%s vtnr=%u",
728                   s->id,
729                   p,
730                   (uint32_t) s->user->uid,
731                   s->user->runtime_path,
732                   fifo_fd,
733                   s->seat ? s->seat->id : "",
734                   (uint32_t) s->vtnr);
735
736         return sd_bus_reply_method_return(
737                         c, "soshusub",
738                         s->id,
739                         p,
740                         s->user->runtime_path,
741                         fifo_fd,
742                         (uint32_t) s->user->uid,
743                         s->seat ? s->seat->id : "",
744                         (uint32_t) s->vtnr,
745                         false);
746 }