]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/sd-bus.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sd-bus: log about bus state changes
[thirdparty/systemd.git] / src / libsystemd / sd-bus / sd-bus.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2013 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include <endian.h>
22 #include <netdb.h>
23 #include <poll.h>
24 #include <pthread.h>
25 #include <stdlib.h>
26 #include <sys/mman.h>
27 #include <unistd.h>
28
29 #include "sd-bus.h"
30
31 #include "alloc-util.h"
32 #include "bus-container.h"
33 #include "bus-control.h"
34 #include "bus-internal.h"
35 #include "bus-kernel.h"
36 #include "bus-label.h"
37 #include "bus-message.h"
38 #include "bus-objects.h"
39 #include "bus-protocol.h"
40 #include "bus-slot.h"
41 #include "bus-socket.h"
42 #include "bus-track.h"
43 #include "bus-type.h"
44 #include "bus-util.h"
45 #include "cgroup-util.h"
46 #include "def.h"
47 #include "fd-util.h"
48 #include "hexdecoct.h"
49 #include "hostname-util.h"
50 #include "macro.h"
51 #include "missing.h"
52 #include "parse-util.h"
53 #include "string-util.h"
54 #include "strv.h"
55 #include "util.h"
56
57 #define log_debug_bus_message(m) \
58 do { \
59 sd_bus_message *_mm = (m); \
60 log_debug("Got message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s", \
61 bus_message_type_to_string(_mm->header->type), \
62 strna(sd_bus_message_get_sender(_mm)), \
63 strna(sd_bus_message_get_destination(_mm)), \
64 strna(sd_bus_message_get_path(_mm)), \
65 strna(sd_bus_message_get_interface(_mm)), \
66 strna(sd_bus_message_get_member(_mm)), \
67 BUS_MESSAGE_COOKIE(_mm), \
68 _mm->reply_cookie, \
69 strna(_mm->root_container.signature), \
70 strna(_mm->error.name), \
71 strna(_mm->error.message)); \
72 } while (false)
73
74 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
75 static void bus_detach_io_events(sd_bus *b);
76 static void bus_detach_inotify_event(sd_bus *b);
77
78 static thread_local sd_bus *default_system_bus = NULL;
79 static thread_local sd_bus *default_user_bus = NULL;
80 static thread_local sd_bus *default_starter_bus = NULL;
81
82 void bus_close_io_fds(sd_bus *b) {
83 assert(b);
84
85 bus_detach_io_events(b);
86
87 if (b->input_fd != b->output_fd)
88 safe_close(b->output_fd);
89 b->output_fd = b->input_fd = safe_close(b->input_fd);
90 }
91
92 void bus_close_inotify_fd(sd_bus *b) {
93 assert(b);
94
95 bus_detach_inotify_event(b);
96
97 b->inotify_fd = safe_close(b->inotify_fd);
98 b->inotify_watches = mfree(b->inotify_watches);
99 b->n_inotify_watches = 0;
100 }
101
102 static void bus_reset_queues(sd_bus *b) {
103 assert(b);
104
105 while (b->rqueue_size > 0)
106 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
107
108 b->rqueue = mfree(b->rqueue);
109 b->rqueue_allocated = 0;
110
111 while (b->wqueue_size > 0)
112 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
113
114 b->wqueue = mfree(b->wqueue);
115 b->wqueue_allocated = 0;
116 }
117
118 static void bus_free(sd_bus *b) {
119 sd_bus_slot *s;
120
121 assert(b);
122 assert(!b->track_queue);
123 assert(!b->tracks);
124
125 b->state = BUS_CLOSED;
126
127 sd_bus_detach_event(b);
128
129 while ((s = b->slots)) {
130 /* At this point only floating slots can still be
131 * around, because the non-floating ones keep a
132 * reference to the bus, and we thus couldn't be
133 * destructing right now... We forcibly disconnect the
134 * slots here, so that they still can be referenced by
135 * apps, but are dead. */
136
137 assert(s->floating);
138 bus_slot_disconnect(s);
139 sd_bus_slot_unref(s);
140 }
141
142 if (b->default_bus_ptr)
143 *b->default_bus_ptr = NULL;
144
145 bus_close_io_fds(b);
146 bus_close_inotify_fd(b);
147
148 free(b->label);
149 free(b->groups);
150 free(b->rbuffer);
151 free(b->unique_name);
152 free(b->auth_buffer);
153 free(b->address);
154 free(b->machine);
155 free(b->cgroup_root);
156 free(b->description);
157
158 free(b->exec_path);
159 strv_free(b->exec_argv);
160
161 close_many(b->fds, b->n_fds);
162 free(b->fds);
163
164 bus_reset_queues(b);
165
166 ordered_hashmap_free_free(b->reply_callbacks);
167 prioq_free(b->reply_callbacks_prioq);
168
169 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
170 bus_match_free(&b->match_callbacks);
171
172 hashmap_free_free(b->vtable_methods);
173 hashmap_free_free(b->vtable_properties);
174
175 assert(hashmap_isempty(b->nodes));
176 hashmap_free(b->nodes);
177
178 bus_flush_memfd(b);
179
180 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
181
182 free(b);
183 }
184
185 _public_ int sd_bus_new(sd_bus **ret) {
186 sd_bus *r;
187
188 assert_return(ret, -EINVAL);
189
190 r = new0(sd_bus, 1);
191 if (!r)
192 return -ENOMEM;
193
194 r->n_ref = REFCNT_INIT;
195 r->input_fd = r->output_fd = -1;
196 r->inotify_fd = -1;
197 r->message_version = 1;
198 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
199 r->accept_fd = true;
200 r->original_pid = getpid_cached();
201 r->n_groups = (size_t) -1;
202
203 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
204
205 /* We guarantee that wqueue always has space for at least one
206 * entry */
207 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
208 free(r);
209 return -ENOMEM;
210 }
211
212 *ret = r;
213 return 0;
214 }
215
216 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
217 char *a;
218
219 assert_return(bus, -EINVAL);
220 assert_return(bus->state == BUS_UNSET, -EPERM);
221 assert_return(address, -EINVAL);
222 assert_return(!bus_pid_changed(bus), -ECHILD);
223
224 a = strdup(address);
225 if (!a)
226 return -ENOMEM;
227
228 free(bus->address);
229 bus->address = a;
230
231 return 0;
232 }
233
234 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
235 assert_return(bus, -EINVAL);
236 assert_return(bus->state == BUS_UNSET, -EPERM);
237 assert_return(input_fd >= 0, -EBADF);
238 assert_return(output_fd >= 0, -EBADF);
239 assert_return(!bus_pid_changed(bus), -ECHILD);
240
241 bus->input_fd = input_fd;
242 bus->output_fd = output_fd;
243 return 0;
244 }
245
246 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
247 char *p, **a;
248
249 assert_return(bus, -EINVAL);
250 assert_return(bus->state == BUS_UNSET, -EPERM);
251 assert_return(path, -EINVAL);
252 assert_return(!strv_isempty(argv), -EINVAL);
253 assert_return(!bus_pid_changed(bus), -ECHILD);
254
255 p = strdup(path);
256 if (!p)
257 return -ENOMEM;
258
259 a = strv_copy(argv);
260 if (!a) {
261 free(p);
262 return -ENOMEM;
263 }
264
265 free(bus->exec_path);
266 strv_free(bus->exec_argv);
267
268 bus->exec_path = p;
269 bus->exec_argv = a;
270
271 return 0;
272 }
273
274 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
275 assert_return(bus, -EINVAL);
276 assert_return(bus->state == BUS_UNSET, -EPERM);
277 assert_return(!bus_pid_changed(bus), -ECHILD);
278
279 bus->bus_client = !!b;
280 return 0;
281 }
282
283 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
284 assert_return(bus, -EINVAL);
285 assert_return(bus->state == BUS_UNSET, -EPERM);
286 assert_return(!bus_pid_changed(bus), -ECHILD);
287
288 bus->is_monitor = b;
289 return 0;
290 }
291
292 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
293 assert_return(bus, -EINVAL);
294 assert_return(bus->state == BUS_UNSET, -EPERM);
295 assert_return(!bus_pid_changed(bus), -ECHILD);
296
297 bus->accept_fd = b;
298 return 0;
299 }
300
301 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
302 assert_return(bus, -EINVAL);
303 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
304 assert_return(!bus_pid_changed(bus), -ECHILD);
305
306 /* This is not actually supported by any of our transports these days, but we do honour it for synthetic
307 * replies, and maybe one day classic D-Bus learns this too */
308 bus->attach_timestamp = b;
309
310 return 0;
311 }
312
313 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
314 assert_return(bus, -EINVAL);
315 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
316 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
317 assert_return(!bus_pid_changed(bus), -ECHILD);
318
319 SET_FLAG(bus->creds_mask, mask, b);
320
321 /* The well knowns we need unconditionally, so that matches can work */
322 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
323
324 return 0;
325 }
326
327 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
328 assert_return(bus, -EINVAL);
329 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
330 assert_return(bus->state == BUS_UNSET, -EPERM);
331 assert_return(!bus_pid_changed(bus), -ECHILD);
332
333 bus->is_server = !!b;
334 bus->server_id = server_id;
335 return 0;
336 }
337
338 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
339 assert_return(bus, -EINVAL);
340 assert_return(bus->state == BUS_UNSET, -EPERM);
341 assert_return(!bus_pid_changed(bus), -ECHILD);
342
343 bus->anonymous_auth = !!b;
344 return 0;
345 }
346
347 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
348 assert_return(bus, -EINVAL);
349 assert_return(bus->state == BUS_UNSET, -EPERM);
350 assert_return(!bus_pid_changed(bus), -ECHILD);
351
352 bus->trusted = !!b;
353 return 0;
354 }
355
356 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
357 assert_return(bus, -EINVAL);
358 assert_return(bus->state == BUS_UNSET, -EPERM);
359 assert_return(!bus_pid_changed(bus), -ECHILD);
360
361 return free_and_strdup(&bus->description, description);
362 }
363
364 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
365 assert_return(bus, -EINVAL);
366 assert_return(!bus_pid_changed(bus), -ECHILD);
367
368 bus->allow_interactive_authorization = !!b;
369 return 0;
370 }
371
372 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
373 assert_return(bus, -EINVAL);
374 assert_return(!bus_pid_changed(bus), -ECHILD);
375
376 return bus->allow_interactive_authorization;
377 }
378
379 _public_ int sd_bus_set_watch_bind(sd_bus *bus, int b) {
380 assert_return(bus, -EINVAL);
381 assert_return(bus->state == BUS_UNSET, -EPERM);
382 assert_return(!bus_pid_changed(bus), -ECHILD);
383
384 bus->watch_bind = b;
385 return 0;
386 }
387
388 _public_ int sd_bus_get_watch_bind(sd_bus *bus) {
389 assert_return(bus, -EINVAL);
390 assert_return(!bus_pid_changed(bus), -ECHILD);
391
392 return bus->watch_bind;
393 }
394
395 _public_ int sd_bus_set_connected_signal(sd_bus *bus, int b) {
396 assert_return(bus, -EINVAL);
397 assert_return(bus->state == BUS_UNSET, -EPERM);
398 assert_return(!bus_pid_changed(bus), -ECHILD);
399
400 bus->connected_signal = b;
401 return 0;
402 }
403
404 _public_ int sd_bus_get_connected_signal(sd_bus *bus) {
405 assert_return(bus, -EINVAL);
406 assert_return(!bus_pid_changed(bus), -ECHILD);
407
408 return bus->connected_signal;
409 }
410
411 static int synthesize_connected_signal(sd_bus *bus) {
412 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
413 int r;
414
415 assert(bus);
416
417 /* If enabled, synthesizes a local "Connected" signal mirroring the local "Disconnected" signal. This is called
418 * whenever we fully established a connection, i.e. after the authorization phase, and after receiving the
419 * Hello() reply. Or in other words, whenver we enter BUS_RUNNING state.
420 *
421 * This is useful so that clients can start doing stuff whenver the connection is fully established in a way
422 * that works independently from whether we connected to a full bus or just a direct connection. */
423
424 if (!bus->connected_signal)
425 return 0;
426
427 r = sd_bus_message_new_signal(
428 bus,
429 &m,
430 "/org/freedesktop/DBus/Local",
431 "org.freedesktop.DBus.Local",
432 "Connected");
433 if (r < 0)
434 return r;
435
436 bus_message_set_sender_local(bus, m);
437
438 r = bus_seal_synthetic_message(bus, m);
439 if (r < 0)
440 return r;
441
442 r = bus_rqueue_make_room(bus);
443 if (r < 0)
444 return r;
445
446 /* Insert at the very front */
447 memmove(bus->rqueue + 1, bus->rqueue, sizeof(sd_bus_message*) * bus->rqueue_size);
448 bus->rqueue[0] = m;
449 m = NULL;
450 bus->rqueue_size++;
451
452 return 0;
453 }
454
455 void bus_set_state(sd_bus *bus, enum bus_state state) {
456
457 static const char * const table[_BUS_STATE_MAX] = {
458 [BUS_UNSET] = "UNSET",
459 [BUS_WATCH_BIND] = "WATCH_BIND",
460 [BUS_OPENING] = "OPENING",
461 [BUS_AUTHENTICATING] = "AUTHENTICATING",
462 [BUS_HELLO] = "HELLO",
463 [BUS_RUNNING] = "RUNNING",
464 [BUS_CLOSING] = "CLOSING",
465 [BUS_CLOSED] = "CLOSED",
466 };
467
468 assert(bus);
469 assert(state < _BUS_STATE_MAX);
470
471 if (state == bus->state)
472 return;
473
474 log_debug("Bus %s: changing state %s → %s", strna(bus->description), table[bus->state], table[state]);
475 bus->state = state;
476 }
477
478 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
479 const char *s;
480 sd_bus *bus;
481 int r;
482
483 assert(reply);
484 bus = reply->bus;
485 assert(bus);
486 assert(IN_SET(bus->state, BUS_HELLO, BUS_CLOSING));
487
488 r = sd_bus_message_get_errno(reply);
489 if (r > 0)
490 return -r;
491
492 r = sd_bus_message_read(reply, "s", &s);
493 if (r < 0)
494 return r;
495
496 if (!service_name_is_valid(s) || s[0] != ':')
497 return -EBADMSG;
498
499 bus->unique_name = strdup(s);
500 if (!bus->unique_name)
501 return -ENOMEM;
502
503 if (bus->state == BUS_HELLO) {
504 bus_set_state(bus, BUS_RUNNING);
505
506 r = synthesize_connected_signal(bus);
507 if (r < 0)
508 return r;
509 }
510
511 return 1;
512 }
513
514 static int bus_send_hello(sd_bus *bus) {
515 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
516 int r;
517
518 assert(bus);
519
520 if (!bus->bus_client)
521 return 0;
522
523 r = sd_bus_message_new_method_call(
524 bus,
525 &m,
526 "org.freedesktop.DBus",
527 "/org/freedesktop/DBus",
528 "org.freedesktop.DBus",
529 "Hello");
530 if (r < 0)
531 return r;
532
533 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
534 }
535
536 int bus_start_running(sd_bus *bus) {
537 struct reply_callback *c;
538 Iterator i;
539 usec_t n;
540 int r;
541
542 assert(bus);
543 assert(bus->state < BUS_HELLO);
544
545 /* We start all method call timeouts when we enter BUS_HELLO or BUS_RUNNING mode. At this point let's convert
546 * all relative to absolute timestamps. Note that we do not reshuffle the reply callback priority queue since
547 * adding a fixed value to all entries should not alter the internal order. */
548
549 n = now(CLOCK_MONOTONIC);
550 ORDERED_HASHMAP_FOREACH(c, bus->reply_callbacks, i) {
551 if (c->timeout_usec == 0)
552 continue;
553
554 c->timeout_usec = usec_add(n, c->timeout_usec);
555 }
556
557 if (bus->bus_client) {
558 bus_set_state(bus, BUS_HELLO);
559 return 1;
560 }
561
562 bus_set_state(bus, BUS_RUNNING);
563
564 r = synthesize_connected_signal(bus);
565 if (r < 0)
566 return r;
567
568 return 1;
569 }
570
571 static int parse_address_key(const char **p, const char *key, char **value) {
572 size_t l, n = 0, allocated = 0;
573 const char *a;
574 char *r = NULL;
575
576 assert(p);
577 assert(*p);
578 assert(value);
579
580 if (key) {
581 l = strlen(key);
582 if (strncmp(*p, key, l) != 0)
583 return 0;
584
585 if ((*p)[l] != '=')
586 return 0;
587
588 if (*value)
589 return -EINVAL;
590
591 a = *p + l + 1;
592 } else
593 a = *p;
594
595 while (!IN_SET(*a, ';', ',', 0)) {
596 char c;
597
598 if (*a == '%') {
599 int x, y;
600
601 x = unhexchar(a[1]);
602 if (x < 0) {
603 free(r);
604 return x;
605 }
606
607 y = unhexchar(a[2]);
608 if (y < 0) {
609 free(r);
610 return y;
611 }
612
613 c = (char) ((x << 4) | y);
614 a += 3;
615 } else {
616 c = *a;
617 a++;
618 }
619
620 if (!GREEDY_REALLOC(r, allocated, n + 2))
621 return -ENOMEM;
622
623 r[n++] = c;
624 }
625
626 if (!r) {
627 r = strdup("");
628 if (!r)
629 return -ENOMEM;
630 } else
631 r[n] = 0;
632
633 if (*a == ',')
634 a++;
635
636 *p = a;
637
638 free(*value);
639 *value = r;
640
641 return 1;
642 }
643
644 static void skip_address_key(const char **p) {
645 assert(p);
646 assert(*p);
647
648 *p += strcspn(*p, ",");
649
650 if (**p == ',')
651 (*p)++;
652 }
653
654 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
655 _cleanup_free_ char *path = NULL, *abstract = NULL;
656 size_t l;
657 int r;
658
659 assert(b);
660 assert(p);
661 assert(*p);
662 assert(guid);
663
664 while (!IN_SET(**p, 0, ';')) {
665 r = parse_address_key(p, "guid", guid);
666 if (r < 0)
667 return r;
668 else if (r > 0)
669 continue;
670
671 r = parse_address_key(p, "path", &path);
672 if (r < 0)
673 return r;
674 else if (r > 0)
675 continue;
676
677 r = parse_address_key(p, "abstract", &abstract);
678 if (r < 0)
679 return r;
680 else if (r > 0)
681 continue;
682
683 skip_address_key(p);
684 }
685
686 if (!path && !abstract)
687 return -EINVAL;
688
689 if (path && abstract)
690 return -EINVAL;
691
692 if (path) {
693 l = strlen(path);
694 if (l > sizeof(b->sockaddr.un.sun_path))
695 return -E2BIG;
696
697 b->sockaddr.un.sun_family = AF_UNIX;
698 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
699 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
700 } else if (abstract) {
701 l = strlen(abstract);
702 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
703 return -E2BIG;
704
705 b->sockaddr.un.sun_family = AF_UNIX;
706 b->sockaddr.un.sun_path[0] = 0;
707 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
708 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
709 }
710
711 b->is_local = true;
712
713 return 0;
714 }
715
716 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
717 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
718 int r;
719 struct addrinfo *result, hints = {
720 .ai_socktype = SOCK_STREAM,
721 .ai_flags = AI_ADDRCONFIG,
722 };
723
724 assert(b);
725 assert(p);
726 assert(*p);
727 assert(guid);
728
729 while (!IN_SET(**p, 0, ';')) {
730 r = parse_address_key(p, "guid", guid);
731 if (r < 0)
732 return r;
733 else if (r > 0)
734 continue;
735
736 r = parse_address_key(p, "host", &host);
737 if (r < 0)
738 return r;
739 else if (r > 0)
740 continue;
741
742 r = parse_address_key(p, "port", &port);
743 if (r < 0)
744 return r;
745 else if (r > 0)
746 continue;
747
748 r = parse_address_key(p, "family", &family);
749 if (r < 0)
750 return r;
751 else if (r > 0)
752 continue;
753
754 skip_address_key(p);
755 }
756
757 if (!host || !port)
758 return -EINVAL;
759
760 if (family) {
761 if (streq(family, "ipv4"))
762 hints.ai_family = AF_INET;
763 else if (streq(family, "ipv6"))
764 hints.ai_family = AF_INET6;
765 else
766 return -EINVAL;
767 }
768
769 r = getaddrinfo(host, port, &hints, &result);
770 if (r == EAI_SYSTEM)
771 return -errno;
772 else if (r != 0)
773 return -EADDRNOTAVAIL;
774
775 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
776 b->sockaddr_size = result->ai_addrlen;
777
778 freeaddrinfo(result);
779
780 b->is_local = false;
781
782 return 0;
783 }
784
785 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
786 char *path = NULL;
787 unsigned n_argv = 0, j;
788 char **argv = NULL;
789 size_t allocated = 0;
790 int r;
791
792 assert(b);
793 assert(p);
794 assert(*p);
795 assert(guid);
796
797 while (!IN_SET(**p, 0, ';')) {
798 r = parse_address_key(p, "guid", guid);
799 if (r < 0)
800 goto fail;
801 else if (r > 0)
802 continue;
803
804 r = parse_address_key(p, "path", &path);
805 if (r < 0)
806 goto fail;
807 else if (r > 0)
808 continue;
809
810 if (startswith(*p, "argv")) {
811 unsigned ul;
812
813 errno = 0;
814 ul = strtoul(*p + 4, (char**) p, 10);
815 if (errno > 0 || **p != '=' || ul > 256) {
816 r = -EINVAL;
817 goto fail;
818 }
819
820 (*p)++;
821
822 if (ul >= n_argv) {
823 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
824 r = -ENOMEM;
825 goto fail;
826 }
827
828 n_argv = ul + 1;
829 }
830
831 r = parse_address_key(p, NULL, argv + ul);
832 if (r < 0)
833 goto fail;
834
835 continue;
836 }
837
838 skip_address_key(p);
839 }
840
841 if (!path) {
842 r = -EINVAL;
843 goto fail;
844 }
845
846 /* Make sure there are no holes in the array, with the
847 * exception of argv[0] */
848 for (j = 1; j < n_argv; j++)
849 if (!argv[j]) {
850 r = -EINVAL;
851 goto fail;
852 }
853
854 if (argv && argv[0] == NULL) {
855 argv[0] = strdup(path);
856 if (!argv[0]) {
857 r = -ENOMEM;
858 goto fail;
859 }
860 }
861
862 b->exec_path = path;
863 b->exec_argv = argv;
864
865 b->is_local = false;
866
867 return 0;
868
869 fail:
870 for (j = 0; j < n_argv; j++)
871 free(argv[j]);
872
873 free(argv);
874 free(path);
875 return r;
876 }
877
878 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
879 _cleanup_free_ char *machine = NULL, *pid = NULL;
880 int r;
881
882 assert(b);
883 assert(p);
884 assert(*p);
885 assert(guid);
886
887 while (!IN_SET(**p, 0, ';')) {
888 r = parse_address_key(p, "guid", guid);
889 if (r < 0)
890 return r;
891 else if (r > 0)
892 continue;
893
894 r = parse_address_key(p, "machine", &machine);
895 if (r < 0)
896 return r;
897 else if (r > 0)
898 continue;
899
900 r = parse_address_key(p, "pid", &pid);
901 if (r < 0)
902 return r;
903 else if (r > 0)
904 continue;
905
906 skip_address_key(p);
907 }
908
909 if (!machine == !pid)
910 return -EINVAL;
911
912 if (machine) {
913 if (!machine_name_is_valid(machine))
914 return -EINVAL;
915
916 free_and_replace(b->machine, machine);
917 } else {
918 b->machine = mfree(b->machine);
919 }
920
921 if (pid) {
922 r = parse_pid(pid, &b->nspid);
923 if (r < 0)
924 return r;
925 } else
926 b->nspid = 0;
927
928 b->sockaddr.un.sun_family = AF_UNIX;
929 /* Note that we use the old /var/run prefix here, to increase compatibility with really old containers */
930 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
931 b->sockaddr_size = SOCKADDR_UN_LEN(b->sockaddr.un);
932 b->is_local = false;
933
934 return 0;
935 }
936
937 static void bus_reset_parsed_address(sd_bus *b) {
938 assert(b);
939
940 zero(b->sockaddr);
941 b->sockaddr_size = 0;
942 b->exec_argv = strv_free(b->exec_argv);
943 b->exec_path = mfree(b->exec_path);
944 b->server_id = SD_ID128_NULL;
945 b->machine = mfree(b->machine);
946 b->nspid = 0;
947 }
948
949 static int bus_parse_next_address(sd_bus *b) {
950 _cleanup_free_ char *guid = NULL;
951 const char *a;
952 int r;
953
954 assert(b);
955
956 if (!b->address)
957 return 0;
958 if (b->address[b->address_index] == 0)
959 return 0;
960
961 bus_reset_parsed_address(b);
962
963 a = b->address + b->address_index;
964
965 while (*a != 0) {
966
967 if (*a == ';') {
968 a++;
969 continue;
970 }
971
972 if (startswith(a, "unix:")) {
973 a += 5;
974
975 r = parse_unix_address(b, &a, &guid);
976 if (r < 0)
977 return r;
978 break;
979
980 } else if (startswith(a, "tcp:")) {
981
982 a += 4;
983 r = parse_tcp_address(b, &a, &guid);
984 if (r < 0)
985 return r;
986
987 break;
988
989 } else if (startswith(a, "unixexec:")) {
990
991 a += 9;
992 r = parse_exec_address(b, &a, &guid);
993 if (r < 0)
994 return r;
995
996 break;
997
998 } else if (startswith(a, "x-machine-unix:")) {
999
1000 a += 15;
1001 r = parse_container_unix_address(b, &a, &guid);
1002 if (r < 0)
1003 return r;
1004
1005 break;
1006 }
1007
1008 a = strchr(a, ';');
1009 if (!a)
1010 return 0;
1011 }
1012
1013 if (guid) {
1014 r = sd_id128_from_string(guid, &b->server_id);
1015 if (r < 0)
1016 return r;
1017 }
1018
1019 b->address_index = a - b->address;
1020 return 1;
1021 }
1022
1023 static int bus_start_address(sd_bus *b) {
1024 int r;
1025
1026 assert(b);
1027
1028 for (;;) {
1029 bus_close_io_fds(b);
1030 bus_close_inotify_fd(b);
1031
1032 /* If you provide multiple different bus-addresses, we
1033 * try all of them in order and use the first one that
1034 * succeeds. */
1035
1036 if (b->exec_path)
1037 r = bus_socket_exec(b);
1038 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1039 r = bus_container_connect_socket(b);
1040 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1041 r = bus_socket_connect(b);
1042 else
1043 goto next;
1044
1045 if (r >= 0) {
1046 int q;
1047
1048 q = bus_attach_io_events(b);
1049 if (q < 0)
1050 return q;
1051
1052 q = bus_attach_inotify_event(b);
1053 if (q < 0)
1054 return q;
1055
1056 return r;
1057 }
1058
1059 b->last_connect_error = -r;
1060
1061 next:
1062 r = bus_parse_next_address(b);
1063 if (r < 0)
1064 return r;
1065 if (r == 0)
1066 return b->last_connect_error > 0 ? -b->last_connect_error : -ECONNREFUSED;
1067 }
1068 }
1069
1070 int bus_next_address(sd_bus *b) {
1071 assert(b);
1072
1073 bus_reset_parsed_address(b);
1074 return bus_start_address(b);
1075 }
1076
1077 static int bus_start_fd(sd_bus *b) {
1078 struct stat st;
1079 int r;
1080
1081 assert(b);
1082 assert(b->input_fd >= 0);
1083 assert(b->output_fd >= 0);
1084
1085 r = fd_nonblock(b->input_fd, true);
1086 if (r < 0)
1087 return r;
1088
1089 r = fd_cloexec(b->input_fd, true);
1090 if (r < 0)
1091 return r;
1092
1093 if (b->input_fd != b->output_fd) {
1094 r = fd_nonblock(b->output_fd, true);
1095 if (r < 0)
1096 return r;
1097
1098 r = fd_cloexec(b->output_fd, true);
1099 if (r < 0)
1100 return r;
1101 }
1102
1103 if (fstat(b->input_fd, &st) < 0)
1104 return -errno;
1105
1106 return bus_socket_take_fd(b);
1107 }
1108
1109 _public_ int sd_bus_start(sd_bus *bus) {
1110 int r;
1111
1112 assert_return(bus, -EINVAL);
1113 assert_return(bus->state == BUS_UNSET, -EPERM);
1114 assert_return(!bus_pid_changed(bus), -ECHILD);
1115
1116 bus_set_state(bus, BUS_OPENING);
1117
1118 if (bus->is_server && bus->bus_client)
1119 return -EINVAL;
1120
1121 if (bus->input_fd >= 0)
1122 r = bus_start_fd(bus);
1123 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->machine)
1124 r = bus_start_address(bus);
1125 else
1126 return -EINVAL;
1127
1128 if (r < 0) {
1129 sd_bus_close(bus);
1130 return r;
1131 }
1132
1133 return bus_send_hello(bus);
1134 }
1135
1136 _public_ int sd_bus_open(sd_bus **ret) {
1137 const char *e;
1138 sd_bus *b;
1139 int r;
1140
1141 assert_return(ret, -EINVAL);
1142
1143 /* Let's connect to the starter bus if it is set, and
1144 * otherwise to the bus that is appropropriate for the scope
1145 * we are running in */
1146
1147 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1148 if (e) {
1149 if (streq(e, "system"))
1150 return sd_bus_open_system(ret);
1151 else if (STR_IN_SET(e, "session", "user"))
1152 return sd_bus_open_user(ret);
1153 }
1154
1155 e = secure_getenv("DBUS_STARTER_ADDRESS");
1156 if (!e) {
1157 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1158 return sd_bus_open_user(ret);
1159 else
1160 return sd_bus_open_system(ret);
1161 }
1162
1163 r = sd_bus_new(&b);
1164 if (r < 0)
1165 return r;
1166
1167 r = sd_bus_set_address(b, e);
1168 if (r < 0)
1169 goto fail;
1170
1171 b->bus_client = true;
1172
1173 /* We don't know whether the bus is trusted or not, so better
1174 * be safe, and authenticate everything */
1175 b->trusted = false;
1176 b->is_local = false;
1177 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1178
1179 r = sd_bus_start(b);
1180 if (r < 0)
1181 goto fail;
1182
1183 *ret = b;
1184 return 0;
1185
1186 fail:
1187 bus_free(b);
1188 return r;
1189 }
1190
1191 int bus_set_address_system(sd_bus *b) {
1192 const char *e;
1193 assert(b);
1194
1195 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1196 if (e)
1197 return sd_bus_set_address(b, e);
1198
1199 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1200 }
1201
1202 _public_ int sd_bus_open_system(sd_bus **ret) {
1203 sd_bus *b;
1204 int r;
1205
1206 assert_return(ret, -EINVAL);
1207
1208 r = sd_bus_new(&b);
1209 if (r < 0)
1210 return r;
1211
1212 r = bus_set_address_system(b);
1213 if (r < 0)
1214 goto fail;
1215
1216 b->bus_client = true;
1217 b->is_system = true;
1218
1219 /* Let's do per-method access control on the system bus. We
1220 * need the caller's UID and capability set for that. */
1221 b->trusted = false;
1222 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1223 b->is_local = true;
1224
1225 r = sd_bus_start(b);
1226 if (r < 0)
1227 goto fail;
1228
1229 *ret = b;
1230 return 0;
1231
1232 fail:
1233 bus_free(b);
1234 return r;
1235 }
1236
1237 int bus_set_address_user(sd_bus *b) {
1238 const char *e;
1239 _cleanup_free_ char *ee = NULL, *s = NULL;
1240
1241 assert(b);
1242
1243 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1244 if (e)
1245 return sd_bus_set_address(b, e);
1246
1247 e = secure_getenv("XDG_RUNTIME_DIR");
1248 if (!e)
1249 return -ENOENT;
1250
1251 ee = bus_address_escape(e);
1252 if (!ee)
1253 return -ENOMEM;
1254
1255 if (asprintf(&s, DEFAULT_USER_BUS_ADDRESS_FMT, ee) < 0)
1256 return -ENOMEM;
1257
1258 b->address = s;
1259 s = NULL;
1260
1261 return 0;
1262 }
1263
1264 _public_ int sd_bus_open_user(sd_bus **ret) {
1265 sd_bus *b;
1266 int r;
1267
1268 assert_return(ret, -EINVAL);
1269
1270 r = sd_bus_new(&b);
1271 if (r < 0)
1272 return r;
1273
1274 r = bus_set_address_user(b);
1275 if (r < 0)
1276 goto fail;
1277
1278 b->bus_client = true;
1279 b->is_user = true;
1280
1281 /* We don't do any per-method access control on the user
1282 * bus. */
1283 b->trusted = true;
1284 b->is_local = true;
1285
1286 r = sd_bus_start(b);
1287 if (r < 0)
1288 goto fail;
1289
1290 *ret = b;
1291 return 0;
1292
1293 fail:
1294 bus_free(b);
1295 return r;
1296 }
1297
1298 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1299 _cleanup_free_ char *e = NULL;
1300 char *m = NULL, *c = NULL;
1301
1302 assert(b);
1303 assert(host);
1304
1305 /* Let's see if we shall enter some container */
1306 m = strchr(host, ':');
1307 if (m) {
1308 m++;
1309
1310 /* Let's make sure this is not a port of some kind,
1311 * and is a valid machine name. */
1312 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1313 char *t;
1314
1315 /* Cut out the host part */
1316 t = strndupa(host, m - host - 1);
1317 e = bus_address_escape(t);
1318 if (!e)
1319 return -ENOMEM;
1320
1321 c = strjoina(",argv5=--machine=", m);
1322 }
1323 }
1324
1325 if (!e) {
1326 e = bus_address_escape(host);
1327 if (!e)
1328 return -ENOMEM;
1329 }
1330
1331 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=systemd-stdio-bridge", c);
1332 if (!b->address)
1333 return -ENOMEM;
1334
1335 return 0;
1336 }
1337
1338 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1339 sd_bus *bus;
1340 int r;
1341
1342 assert_return(host, -EINVAL);
1343 assert_return(ret, -EINVAL);
1344
1345 r = sd_bus_new(&bus);
1346 if (r < 0)
1347 return r;
1348
1349 r = bus_set_address_system_remote(bus, host);
1350 if (r < 0)
1351 goto fail;
1352
1353 bus->bus_client = true;
1354 bus->trusted = false;
1355 bus->is_system = true;
1356 bus->is_local = false;
1357
1358 r = sd_bus_start(bus);
1359 if (r < 0)
1360 goto fail;
1361
1362 *ret = bus;
1363 return 0;
1364
1365 fail:
1366 bus_free(bus);
1367 return r;
1368 }
1369
1370 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1371 _cleanup_free_ char *e = NULL;
1372
1373 assert(b);
1374 assert(machine);
1375
1376 e = bus_address_escape(machine);
1377 if (!e)
1378 return -ENOMEM;
1379
1380 b->address = strjoin("x-machine-unix:machine=", e);
1381 if (!b->address)
1382 return -ENOMEM;
1383
1384 return 0;
1385 }
1386
1387 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1388 sd_bus *bus;
1389 int r;
1390
1391 assert_return(machine, -EINVAL);
1392 assert_return(ret, -EINVAL);
1393 assert_return(machine_name_is_valid(machine), -EINVAL);
1394
1395 r = sd_bus_new(&bus);
1396 if (r < 0)
1397 return r;
1398
1399 r = bus_set_address_system_machine(bus, machine);
1400 if (r < 0)
1401 goto fail;
1402
1403 bus->bus_client = true;
1404 bus->trusted = false;
1405 bus->is_system = true;
1406 bus->is_local = false;
1407
1408 r = sd_bus_start(bus);
1409 if (r < 0)
1410 goto fail;
1411
1412 *ret = bus;
1413 return 0;
1414
1415 fail:
1416 bus_free(bus);
1417 return r;
1418 }
1419
1420 _public_ void sd_bus_close(sd_bus *bus) {
1421
1422 if (!bus)
1423 return;
1424 if (bus->state == BUS_CLOSED)
1425 return;
1426 if (bus_pid_changed(bus))
1427 return;
1428
1429 bus_set_state(bus, BUS_CLOSED);
1430
1431 sd_bus_detach_event(bus);
1432
1433 /* Drop all queued messages so that they drop references to
1434 * the bus object and the bus may be freed */
1435 bus_reset_queues(bus);
1436
1437 bus_close_io_fds(bus);
1438 bus_close_inotify_fd(bus);
1439 }
1440
1441 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1442
1443 if (!bus)
1444 return NULL;
1445
1446 sd_bus_flush(bus);
1447 sd_bus_close(bus);
1448
1449 return sd_bus_unref(bus);
1450 }
1451
1452 void bus_enter_closing(sd_bus *bus) {
1453 assert(bus);
1454
1455 if (!IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1456 return;
1457
1458 bus_set_state(bus, BUS_CLOSING);
1459 }
1460
1461 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1462
1463 if (!bus)
1464 return NULL;
1465
1466 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1467
1468 return bus;
1469 }
1470
1471 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1472 unsigned i;
1473
1474 if (!bus)
1475 return NULL;
1476
1477 i = REFCNT_DEC(bus->n_ref);
1478 if (i > 0)
1479 return NULL;
1480
1481 bus_free(bus);
1482 return NULL;
1483 }
1484
1485 _public_ int sd_bus_is_open(sd_bus *bus) {
1486
1487 assert_return(bus, -EINVAL);
1488 assert_return(!bus_pid_changed(bus), -ECHILD);
1489
1490 return BUS_IS_OPEN(bus->state);
1491 }
1492
1493 _public_ int sd_bus_is_ready(sd_bus *bus) {
1494 assert_return(bus, -EINVAL);
1495 assert_return(!bus_pid_changed(bus), -ECHILD);
1496
1497 return bus->state == BUS_RUNNING;
1498 }
1499
1500 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1501 int r;
1502
1503 assert_return(bus, -EINVAL);
1504 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1505 assert_return(!bus_pid_changed(bus), -ECHILD);
1506
1507 if (bus->is_monitor)
1508 return 0;
1509
1510 if (type == SD_BUS_TYPE_UNIX_FD) {
1511 if (!bus->accept_fd)
1512 return 0;
1513
1514 r = bus_ensure_running(bus);
1515 if (r < 0)
1516 return r;
1517
1518 return bus->can_fds;
1519 }
1520
1521 return bus_type_is_valid(type);
1522 }
1523
1524 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1525 int r;
1526
1527 assert_return(bus, -EINVAL);
1528 assert_return(id, -EINVAL);
1529 assert_return(!bus_pid_changed(bus), -ECHILD);
1530
1531 r = bus_ensure_running(bus);
1532 if (r < 0)
1533 return r;
1534
1535 *id = bus->server_id;
1536 return 0;
1537 }
1538
1539 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1540 assert(b);
1541 assert(m);
1542
1543 if (m->sealed) {
1544 /* If we copy the same message to multiple
1545 * destinations, avoid using the same cookie
1546 * numbers. */
1547 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1548 return 0;
1549 }
1550
1551 if (timeout == 0)
1552 timeout = BUS_DEFAULT_TIMEOUT;
1553
1554 return sd_bus_message_seal(m, ++b->cookie, timeout);
1555 }
1556
1557 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1558 bool remarshal = false;
1559
1560 assert(b);
1561
1562 /* wrong packet version */
1563 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1564 remarshal = true;
1565
1566 /* wrong packet endianness */
1567 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1568 remarshal = true;
1569
1570 return remarshal ? bus_message_remarshal(b, m) : 0;
1571 }
1572
1573 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1574 assert(b);
1575 assert(m);
1576
1577 /* Fake some timestamps, if they were requested, and not
1578 * already initialized */
1579 if (b->attach_timestamp) {
1580 if (m->realtime <= 0)
1581 m->realtime = now(CLOCK_REALTIME);
1582
1583 if (m->monotonic <= 0)
1584 m->monotonic = now(CLOCK_MONOTONIC);
1585 }
1586
1587 /* The bus specification says the serial number cannot be 0,
1588 * hence let's fill something in for synthetic messages. Since
1589 * synthetic messages might have a fake sender and we don't
1590 * want to interfere with the real sender's serial numbers we
1591 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1592 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1593 * even though kdbus can do 64bit. */
1594 return sd_bus_message_seal(m, 0xFFFFFFFFULL, 0);
1595 }
1596
1597 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1598 int r;
1599
1600 assert(bus);
1601 assert(m);
1602
1603 r = bus_socket_write_message(bus, m, idx);
1604 if (r <= 0)
1605 return r;
1606
1607 if (*idx >= BUS_MESSAGE_SIZE(m))
1608 log_debug("Sent message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s",
1609 bus_message_type_to_string(m->header->type),
1610 strna(sd_bus_message_get_sender(m)),
1611 strna(sd_bus_message_get_destination(m)),
1612 strna(sd_bus_message_get_path(m)),
1613 strna(sd_bus_message_get_interface(m)),
1614 strna(sd_bus_message_get_member(m)),
1615 BUS_MESSAGE_COOKIE(m),
1616 m->reply_cookie,
1617 strna(m->root_container.signature),
1618 strna(m->error.name),
1619 strna(m->error.message));
1620
1621 return r;
1622 }
1623
1624 static int dispatch_wqueue(sd_bus *bus) {
1625 int r, ret = 0;
1626
1627 assert(bus);
1628 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1629
1630 while (bus->wqueue_size > 0) {
1631
1632 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1633 if (r < 0)
1634 return r;
1635 else if (r == 0)
1636 /* Didn't do anything this time */
1637 return ret;
1638 else if (bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1639 /* Fully written. Let's drop the entry from
1640 * the queue.
1641 *
1642 * This isn't particularly optimized, but
1643 * well, this is supposed to be our worst-case
1644 * buffer only, and the socket buffer is
1645 * supposed to be our primary buffer, and if
1646 * it got full, then all bets are off
1647 * anyway. */
1648
1649 bus->wqueue_size--;
1650 sd_bus_message_unref(bus->wqueue[0]);
1651 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1652 bus->windex = 0;
1653
1654 ret = 1;
1655 }
1656 }
1657
1658 return ret;
1659 }
1660
1661 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1662 assert(bus);
1663
1664 return bus_socket_read_message(bus);
1665 }
1666
1667 int bus_rqueue_make_room(sd_bus *bus) {
1668 assert(bus);
1669
1670 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1671 return -ENOBUFS;
1672
1673 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1674 return -ENOMEM;
1675
1676 return 0;
1677 }
1678
1679 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1680 int r, ret = 0;
1681
1682 assert(bus);
1683 assert(m);
1684 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1685
1686 /* Note that the priority logic is only available on kdbus,
1687 * where the rqueue is unused. We check the rqueue here
1688 * anyway, because it's simple... */
1689
1690 for (;;) {
1691 if (bus->rqueue_size > 0) {
1692 /* Dispatch a queued message */
1693
1694 *m = bus->rqueue[0];
1695 bus->rqueue_size--;
1696 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1697 return 1;
1698 }
1699
1700 /* Try to read a new message */
1701 r = bus_read_message(bus, hint_priority, priority);
1702 if (r < 0)
1703 return r;
1704 if (r == 0)
1705 return ret;
1706
1707 ret = 1;
1708 }
1709 }
1710
1711 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1712 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1713 int r;
1714
1715 assert_return(m, -EINVAL);
1716
1717 if (!bus)
1718 bus = m->bus;
1719
1720 assert_return(!bus_pid_changed(bus), -ECHILD);
1721
1722 if (!BUS_IS_OPEN(bus->state))
1723 return -ENOTCONN;
1724
1725 if (m->n_fds > 0) {
1726 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1727 if (r < 0)
1728 return r;
1729 if (r == 0)
1730 return -EOPNOTSUPP;
1731 }
1732
1733 /* If the cookie number isn't kept, then we know that no reply
1734 * is expected */
1735 if (!cookie && !m->sealed)
1736 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1737
1738 r = bus_seal_message(bus, m, 0);
1739 if (r < 0)
1740 return r;
1741
1742 /* Remarshall if we have to. This will possibly unref the
1743 * message and place a replacement in m */
1744 r = bus_remarshal_message(bus, &m);
1745 if (r < 0)
1746 return r;
1747
1748 /* If this is a reply and no reply was requested, then let's
1749 * suppress this, if we can */
1750 if (m->dont_send)
1751 goto finish;
1752
1753 if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1754 size_t idx = 0;
1755
1756 r = bus_write_message(bus, m, hint_sync_call, &idx);
1757 if (r < 0) {
1758 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1759 bus_enter_closing(bus);
1760 return -ECONNRESET;
1761 }
1762
1763 return r;
1764 }
1765
1766 if (idx < BUS_MESSAGE_SIZE(m)) {
1767 /* Wasn't fully written. So let's remember how
1768 * much was written. Note that the first entry
1769 * of the wqueue array is always allocated so
1770 * that we always can remember how much was
1771 * written. */
1772 bus->wqueue[0] = sd_bus_message_ref(m);
1773 bus->wqueue_size = 1;
1774 bus->windex = idx;
1775 }
1776
1777 } else {
1778 /* Just append it to the queue. */
1779
1780 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1781 return -ENOBUFS;
1782
1783 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1784 return -ENOMEM;
1785
1786 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1787 }
1788
1789 finish:
1790 if (cookie)
1791 *cookie = BUS_MESSAGE_COOKIE(m);
1792
1793 return 1;
1794 }
1795
1796 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1797 return bus_send_internal(bus, m, cookie, false);
1798 }
1799
1800 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1801 int r;
1802
1803 assert_return(m, -EINVAL);
1804
1805 if (!bus)
1806 bus = m->bus;
1807
1808 assert_return(!bus_pid_changed(bus), -ECHILD);
1809
1810 if (!BUS_IS_OPEN(bus->state))
1811 return -ENOTCONN;
1812
1813 if (!streq_ptr(m->destination, destination)) {
1814
1815 if (!destination)
1816 return -EEXIST;
1817
1818 r = sd_bus_message_set_destination(m, destination);
1819 if (r < 0)
1820 return r;
1821 }
1822
1823 return sd_bus_send(bus, m, cookie);
1824 }
1825
1826 static usec_t calc_elapse(sd_bus *bus, uint64_t usec) {
1827 assert(bus);
1828
1829 if (usec == (uint64_t) -1)
1830 return 0;
1831
1832 /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1833 * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1834 * relative timestamp, and afterwards the absolute one. */
1835
1836 if (IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING))
1837 return usec;
1838 else
1839 return now(CLOCK_MONOTONIC) + usec;
1840 }
1841
1842 static int timeout_compare(const void *a, const void *b) {
1843 const struct reply_callback *x = a, *y = b;
1844
1845 if (x->timeout_usec != 0 && y->timeout_usec == 0)
1846 return -1;
1847
1848 if (x->timeout_usec == 0 && y->timeout_usec != 0)
1849 return 1;
1850
1851 if (x->timeout_usec < y->timeout_usec)
1852 return -1;
1853
1854 if (x->timeout_usec > y->timeout_usec)
1855 return 1;
1856
1857 return 0;
1858 }
1859
1860 _public_ int sd_bus_call_async(
1861 sd_bus *bus,
1862 sd_bus_slot **slot,
1863 sd_bus_message *_m,
1864 sd_bus_message_handler_t callback,
1865 void *userdata,
1866 uint64_t usec) {
1867
1868 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1869 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1870 int r;
1871
1872 assert_return(m, -EINVAL);
1873 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1874 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1875 assert_return(callback, -EINVAL);
1876
1877 if (!bus)
1878 bus = m->bus;
1879
1880 assert_return(!bus_pid_changed(bus), -ECHILD);
1881
1882 if (!BUS_IS_OPEN(bus->state))
1883 return -ENOTCONN;
1884
1885 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1886 if (r < 0)
1887 return r;
1888
1889 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1890 if (r < 0)
1891 return r;
1892
1893 r = bus_seal_message(bus, m, usec);
1894 if (r < 0)
1895 return r;
1896
1897 r = bus_remarshal_message(bus, &m);
1898 if (r < 0)
1899 return r;
1900
1901 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1902 if (!s)
1903 return -ENOMEM;
1904
1905 s->reply_callback.callback = callback;
1906
1907 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1908 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1909 if (r < 0) {
1910 s->reply_callback.cookie = 0;
1911 return r;
1912 }
1913
1914 s->reply_callback.timeout_usec = calc_elapse(bus, m->timeout);
1915 if (s->reply_callback.timeout_usec != 0) {
1916 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1917 if (r < 0) {
1918 s->reply_callback.timeout_usec = 0;
1919 return r;
1920 }
1921 }
1922
1923 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1924 if (r < 0)
1925 return r;
1926
1927 if (slot)
1928 *slot = s;
1929 s = NULL;
1930
1931 return r;
1932 }
1933
1934 int bus_ensure_running(sd_bus *bus) {
1935 int r;
1936
1937 assert(bus);
1938
1939 if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
1940 return -ENOTCONN;
1941 if (bus->state == BUS_RUNNING)
1942 return 1;
1943
1944 for (;;) {
1945 r = sd_bus_process(bus, NULL);
1946 if (r < 0)
1947 return r;
1948 if (bus->state == BUS_RUNNING)
1949 return 1;
1950 if (r > 0)
1951 continue;
1952
1953 r = sd_bus_wait(bus, (uint64_t) -1);
1954 if (r < 0)
1955 return r;
1956 }
1957 }
1958
1959 _public_ int sd_bus_call(
1960 sd_bus *bus,
1961 sd_bus_message *_m,
1962 uint64_t usec,
1963 sd_bus_error *error,
1964 sd_bus_message **reply) {
1965
1966 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1967 usec_t timeout;
1968 uint64_t cookie;
1969 unsigned i;
1970 int r;
1971
1972 bus_assert_return(m, -EINVAL, error);
1973 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
1974 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
1975 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
1976
1977 if (!bus)
1978 bus = m->bus;
1979
1980 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
1981
1982 if (!BUS_IS_OPEN(bus->state)) {
1983 r = -ENOTCONN;
1984 goto fail;
1985 }
1986
1987 r = bus_ensure_running(bus);
1988 if (r < 0)
1989 goto fail;
1990
1991 i = bus->rqueue_size;
1992
1993 r = bus_seal_message(bus, m, usec);
1994 if (r < 0)
1995 goto fail;
1996
1997 r = bus_remarshal_message(bus, &m);
1998 if (r < 0)
1999 goto fail;
2000
2001 r = bus_send_internal(bus, m, &cookie, true);
2002 if (r < 0)
2003 goto fail;
2004
2005 timeout = calc_elapse(bus, m->timeout);
2006
2007 for (;;) {
2008 usec_t left;
2009
2010 while (i < bus->rqueue_size) {
2011 sd_bus_message *incoming = NULL;
2012
2013 incoming = bus->rqueue[i];
2014
2015 if (incoming->reply_cookie == cookie) {
2016 /* Found a match! */
2017
2018 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2019 bus->rqueue_size--;
2020 log_debug_bus_message(incoming);
2021
2022 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2023
2024 if (incoming->n_fds <= 0 || bus->accept_fd) {
2025 if (reply)
2026 *reply = incoming;
2027 else
2028 sd_bus_message_unref(incoming);
2029
2030 return 1;
2031 }
2032
2033 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2034 sd_bus_message_unref(incoming);
2035 return r;
2036
2037 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2038 r = sd_bus_error_copy(error, &incoming->error);
2039 sd_bus_message_unref(incoming);
2040 return r;
2041 } else {
2042 r = -EIO;
2043 goto fail;
2044 }
2045
2046 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2047 bus->unique_name &&
2048 incoming->sender &&
2049 streq(bus->unique_name, incoming->sender)) {
2050
2051 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2052 bus->rqueue_size--;
2053
2054 /* Our own message? Somebody is trying
2055 * to send its own client a message,
2056 * let's not dead-lock, let's fail
2057 * immediately. */
2058
2059 sd_bus_message_unref(incoming);
2060 r = -ELOOP;
2061 goto fail;
2062 }
2063
2064 /* Try to read more, right-away */
2065 i++;
2066 }
2067
2068 r = bus_read_message(bus, false, 0);
2069 if (r < 0) {
2070 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2071 bus_enter_closing(bus);
2072 r = -ECONNRESET;
2073 }
2074
2075 goto fail;
2076 }
2077 if (r > 0)
2078 continue;
2079
2080 if (timeout > 0) {
2081 usec_t n;
2082
2083 n = now(CLOCK_MONOTONIC);
2084 if (n >= timeout) {
2085 r = -ETIMEDOUT;
2086 goto fail;
2087 }
2088
2089 left = timeout - n;
2090 } else
2091 left = (uint64_t) -1;
2092
2093 r = bus_poll(bus, true, left);
2094 if (r < 0)
2095 goto fail;
2096 if (r == 0) {
2097 r = -ETIMEDOUT;
2098 goto fail;
2099 }
2100
2101 r = dispatch_wqueue(bus);
2102 if (r < 0) {
2103 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2104 bus_enter_closing(bus);
2105 r = -ECONNRESET;
2106 }
2107
2108 goto fail;
2109 }
2110 }
2111
2112 fail:
2113 return sd_bus_error_set_errno(error, r);
2114 }
2115
2116 _public_ int sd_bus_get_fd(sd_bus *bus) {
2117
2118 assert_return(bus, -EINVAL);
2119 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2120 assert_return(!bus_pid_changed(bus), -ECHILD);
2121
2122 if (bus->state == BUS_CLOSED)
2123 return -ENOTCONN;
2124
2125 if (bus->inotify_fd >= 0)
2126 return bus->inotify_fd;
2127
2128 if (bus->input_fd >= 0)
2129 return bus->input_fd;
2130
2131 return -ENOTCONN;
2132 }
2133
2134 _public_ int sd_bus_get_events(sd_bus *bus) {
2135 int flags = 0;
2136
2137 assert_return(bus, -EINVAL);
2138 assert_return(!bus_pid_changed(bus), -ECHILD);
2139
2140 switch (bus->state) {
2141
2142 case BUS_UNSET:
2143 case BUS_CLOSED:
2144 return -ENOTCONN;
2145
2146 case BUS_WATCH_BIND:
2147 flags |= POLLIN;
2148 break;
2149
2150 case BUS_OPENING:
2151 flags |= POLLOUT;
2152 break;
2153
2154 case BUS_AUTHENTICATING:
2155 if (bus_socket_auth_needs_write(bus))
2156 flags |= POLLOUT;
2157
2158 flags |= POLLIN;
2159 break;
2160
2161 case BUS_RUNNING:
2162 case BUS_HELLO:
2163 if (bus->rqueue_size <= 0)
2164 flags |= POLLIN;
2165 if (bus->wqueue_size > 0)
2166 flags |= POLLOUT;
2167 break;
2168
2169 case BUS_CLOSING:
2170 break;
2171
2172 default:
2173 assert_not_reached("Unknown state");
2174 }
2175
2176 return flags;
2177 }
2178
2179 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2180 struct reply_callback *c;
2181
2182 assert_return(bus, -EINVAL);
2183 assert_return(timeout_usec, -EINVAL);
2184 assert_return(!bus_pid_changed(bus), -ECHILD);
2185
2186 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2187 return -ENOTCONN;
2188
2189 if (bus->track_queue) {
2190 *timeout_usec = 0;
2191 return 1;
2192 }
2193
2194 switch (bus->state) {
2195
2196 case BUS_AUTHENTICATING:
2197 *timeout_usec = bus->auth_timeout;
2198 return 1;
2199
2200 case BUS_RUNNING:
2201 case BUS_HELLO:
2202 if (bus->rqueue_size > 0) {
2203 *timeout_usec = 0;
2204 return 1;
2205 }
2206
2207 c = prioq_peek(bus->reply_callbacks_prioq);
2208 if (!c) {
2209 *timeout_usec = (uint64_t) -1;
2210 return 0;
2211 }
2212
2213 if (c->timeout_usec == 0) {
2214 *timeout_usec = (uint64_t) -1;
2215 return 0;
2216 }
2217
2218 *timeout_usec = c->timeout_usec;
2219 return 1;
2220
2221 case BUS_CLOSING:
2222 *timeout_usec = 0;
2223 return 1;
2224
2225 case BUS_WATCH_BIND:
2226 case BUS_OPENING:
2227 *timeout_usec = (uint64_t) -1;
2228 return 0;
2229
2230 default:
2231 assert_not_reached("Unknown or unexpected stat");
2232 }
2233 }
2234
2235 static int process_timeout(sd_bus *bus) {
2236 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2237 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2238 struct reply_callback *c;
2239 sd_bus_slot *slot;
2240 bool is_hello;
2241 usec_t n;
2242 int r;
2243
2244 assert(bus);
2245 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2246
2247 c = prioq_peek(bus->reply_callbacks_prioq);
2248 if (!c)
2249 return 0;
2250
2251 n = now(CLOCK_MONOTONIC);
2252 if (c->timeout_usec > n)
2253 return 0;
2254
2255 r = bus_message_new_synthetic_error(
2256 bus,
2257 c->cookie,
2258 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2259 &m);
2260 if (r < 0)
2261 return r;
2262
2263 r = bus_seal_synthetic_message(bus, m);
2264 if (r < 0)
2265 return r;
2266
2267 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2268 c->timeout_usec = 0;
2269
2270 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2271 c->cookie = 0;
2272
2273 slot = container_of(c, sd_bus_slot, reply_callback);
2274
2275 bus->iteration_counter++;
2276
2277 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2278
2279 bus->current_message = m;
2280 bus->current_slot = sd_bus_slot_ref(slot);
2281 bus->current_handler = c->callback;
2282 bus->current_userdata = slot->userdata;
2283 r = c->callback(m, slot->userdata, &error_buffer);
2284 bus->current_userdata = NULL;
2285 bus->current_handler = NULL;
2286 bus->current_slot = NULL;
2287 bus->current_message = NULL;
2288
2289 if (slot->floating) {
2290 bus_slot_disconnect(slot);
2291 sd_bus_slot_unref(slot);
2292 }
2293
2294 sd_bus_slot_unref(slot);
2295
2296 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2297 * and ignore the callback handler's return value. */
2298 if (is_hello)
2299 return r;
2300
2301 return bus_maybe_reply_error(m, r, &error_buffer);
2302 }
2303
2304 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2305 assert(bus);
2306 assert(m);
2307
2308 if (bus->state != BUS_HELLO)
2309 return 0;
2310
2311 /* Let's make sure the first message on the bus is the HELLO
2312 * reply. But note that we don't actually parse the message
2313 * here (we leave that to the usual handling), we just verify
2314 * we don't let any earlier msg through. */
2315
2316 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2317 return -EIO;
2318
2319 if (m->reply_cookie != 1)
2320 return -EIO;
2321
2322 return 0;
2323 }
2324
2325 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2326 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2327 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2328 struct reply_callback *c;
2329 sd_bus_slot *slot;
2330 bool is_hello;
2331 int r;
2332
2333 assert(bus);
2334 assert(m);
2335
2336 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2337 return 0;
2338
2339 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2340 return 0;
2341
2342 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2343 if (!c)
2344 return 0;
2345
2346 c->cookie = 0;
2347
2348 slot = container_of(c, sd_bus_slot, reply_callback);
2349
2350 if (m->n_fds > 0 && !bus->accept_fd) {
2351
2352 /* If the reply contained a file descriptor which we
2353 * didn't want we pass an error instead. */
2354
2355 r = bus_message_new_synthetic_error(
2356 bus,
2357 m->reply_cookie,
2358 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2359 &synthetic_reply);
2360 if (r < 0)
2361 return r;
2362
2363 /* Copy over original timestamp */
2364 synthetic_reply->realtime = m->realtime;
2365 synthetic_reply->monotonic = m->monotonic;
2366 synthetic_reply->seqnum = m->seqnum;
2367
2368 r = bus_seal_synthetic_message(bus, synthetic_reply);
2369 if (r < 0)
2370 return r;
2371
2372 m = synthetic_reply;
2373 } else {
2374 r = sd_bus_message_rewind(m, true);
2375 if (r < 0)
2376 return r;
2377 }
2378
2379 if (c->timeout_usec != 0) {
2380 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2381 c->timeout_usec = 0;
2382 }
2383
2384 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2385
2386 bus->current_slot = sd_bus_slot_ref(slot);
2387 bus->current_handler = c->callback;
2388 bus->current_userdata = slot->userdata;
2389 r = c->callback(m, slot->userdata, &error_buffer);
2390 bus->current_userdata = NULL;
2391 bus->current_handler = NULL;
2392 bus->current_slot = NULL;
2393
2394 if (slot->floating) {
2395 bus_slot_disconnect(slot);
2396 sd_bus_slot_unref(slot);
2397 }
2398
2399 sd_bus_slot_unref(slot);
2400
2401 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2402 * ignore the callback handler's return value. */
2403 if (is_hello)
2404 return r;
2405
2406 return bus_maybe_reply_error(m, r, &error_buffer);
2407 }
2408
2409 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2410 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2411 struct filter_callback *l;
2412 int r;
2413
2414 assert(bus);
2415 assert(m);
2416
2417 do {
2418 bus->filter_callbacks_modified = false;
2419
2420 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2421 sd_bus_slot *slot;
2422
2423 if (bus->filter_callbacks_modified)
2424 break;
2425
2426 /* Don't run this more than once per iteration */
2427 if (l->last_iteration == bus->iteration_counter)
2428 continue;
2429
2430 l->last_iteration = bus->iteration_counter;
2431
2432 r = sd_bus_message_rewind(m, true);
2433 if (r < 0)
2434 return r;
2435
2436 slot = container_of(l, sd_bus_slot, filter_callback);
2437
2438 bus->current_slot = sd_bus_slot_ref(slot);
2439 bus->current_handler = l->callback;
2440 bus->current_userdata = slot->userdata;
2441 r = l->callback(m, slot->userdata, &error_buffer);
2442 bus->current_userdata = NULL;
2443 bus->current_handler = NULL;
2444 bus->current_slot = sd_bus_slot_unref(slot);
2445
2446 r = bus_maybe_reply_error(m, r, &error_buffer);
2447 if (r != 0)
2448 return r;
2449
2450 }
2451
2452 } while (bus->filter_callbacks_modified);
2453
2454 return 0;
2455 }
2456
2457 static int process_match(sd_bus *bus, sd_bus_message *m) {
2458 int r;
2459
2460 assert(bus);
2461 assert(m);
2462
2463 do {
2464 bus->match_callbacks_modified = false;
2465
2466 r = bus_match_run(bus, &bus->match_callbacks, m);
2467 if (r != 0)
2468 return r;
2469
2470 } while (bus->match_callbacks_modified);
2471
2472 return 0;
2473 }
2474
2475 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2476 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2477 int r;
2478
2479 assert(bus);
2480 assert(m);
2481
2482 if (bus->is_monitor)
2483 return 0;
2484
2485 if (bus->manual_peer_interface)
2486 return 0;
2487
2488 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2489 return 0;
2490
2491 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2492 return 0;
2493
2494 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2495 return 1;
2496
2497 if (streq_ptr(m->member, "Ping"))
2498 r = sd_bus_message_new_method_return(m, &reply);
2499 else if (streq_ptr(m->member, "GetMachineId")) {
2500 sd_id128_t id;
2501 char sid[33];
2502
2503 r = sd_id128_get_machine(&id);
2504 if (r < 0)
2505 return r;
2506
2507 r = sd_bus_message_new_method_return(m, &reply);
2508 if (r < 0)
2509 return r;
2510
2511 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2512 } else {
2513 r = sd_bus_message_new_method_errorf(
2514 m, &reply,
2515 SD_BUS_ERROR_UNKNOWN_METHOD,
2516 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2517 }
2518
2519 if (r < 0)
2520 return r;
2521
2522 r = sd_bus_send(bus, reply, NULL);
2523 if (r < 0)
2524 return r;
2525
2526 return 1;
2527 }
2528
2529 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2530 assert(bus);
2531 assert(m);
2532
2533 /* If we got a message with a file descriptor which we didn't
2534 * want to accept, then let's drop it. How can this even
2535 * happen? For example, when the kernel queues a message into
2536 * an activatable names's queue which allows fds, and then is
2537 * delivered to us later even though we ourselves did not
2538 * negotiate it. */
2539
2540 if (bus->is_monitor)
2541 return 0;
2542
2543 if (m->n_fds <= 0)
2544 return 0;
2545
2546 if (bus->accept_fd)
2547 return 0;
2548
2549 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2550 return 1; /* just eat it up */
2551
2552 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2553 }
2554
2555 static int process_message(sd_bus *bus, sd_bus_message *m) {
2556 int r;
2557
2558 assert(bus);
2559 assert(m);
2560
2561 bus->current_message = m;
2562 bus->iteration_counter++;
2563
2564 log_debug_bus_message(m);
2565
2566 r = process_hello(bus, m);
2567 if (r != 0)
2568 goto finish;
2569
2570 r = process_reply(bus, m);
2571 if (r != 0)
2572 goto finish;
2573
2574 r = process_fd_check(bus, m);
2575 if (r != 0)
2576 goto finish;
2577
2578 r = process_filter(bus, m);
2579 if (r != 0)
2580 goto finish;
2581
2582 r = process_match(bus, m);
2583 if (r != 0)
2584 goto finish;
2585
2586 r = process_builtin(bus, m);
2587 if (r != 0)
2588 goto finish;
2589
2590 r = bus_process_object(bus, m);
2591
2592 finish:
2593 bus->current_message = NULL;
2594 return r;
2595 }
2596
2597 static int dispatch_track(sd_bus *bus) {
2598 assert(bus);
2599
2600 if (!bus->track_queue)
2601 return 0;
2602
2603 bus_track_dispatch(bus->track_queue);
2604 return 1;
2605 }
2606
2607 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2608 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2609 int r;
2610
2611 assert(bus);
2612 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2613
2614 r = process_timeout(bus);
2615 if (r != 0)
2616 goto null_message;
2617
2618 r = dispatch_wqueue(bus);
2619 if (r != 0)
2620 goto null_message;
2621
2622 r = dispatch_track(bus);
2623 if (r != 0)
2624 goto null_message;
2625
2626 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2627 if (r < 0)
2628 return r;
2629 if (!m)
2630 goto null_message;
2631
2632 r = process_message(bus, m);
2633 if (r != 0)
2634 goto null_message;
2635
2636 if (ret) {
2637 r = sd_bus_message_rewind(m, true);
2638 if (r < 0)
2639 return r;
2640
2641 *ret = m;
2642 m = NULL;
2643 return 1;
2644 }
2645
2646 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2647
2648 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2649 strna(sd_bus_message_get_sender(m)),
2650 strna(sd_bus_message_get_path(m)),
2651 strna(sd_bus_message_get_interface(m)),
2652 strna(sd_bus_message_get_member(m)));
2653
2654 r = sd_bus_reply_method_errorf(
2655 m,
2656 SD_BUS_ERROR_UNKNOWN_OBJECT,
2657 "Unknown object '%s'.", m->path);
2658 if (r < 0)
2659 return r;
2660 }
2661
2662 return 1;
2663
2664 null_message:
2665 if (r >= 0 && ret)
2666 *ret = NULL;
2667
2668 return r;
2669 }
2670
2671 static int bus_exit_now(sd_bus *bus) {
2672 assert(bus);
2673
2674 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2675 * sd_event_exit(), otherwise invokes libc exit(). */
2676
2677 if (bus->exited) /* did we already exit? */
2678 return 0;
2679 if (!bus->exit_triggered) /* was the exit condition triggered? */
2680 return 0;
2681 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2682 return 0;
2683
2684 bus->exited = true; /* never exit more than once */
2685
2686 log_debug("Bus connection disconnected, exiting.");
2687
2688 if (bus->event)
2689 return sd_event_exit(bus->event, EXIT_FAILURE);
2690 else
2691 exit(EXIT_FAILURE);
2692
2693 assert_not_reached("exit() didn't exit?");
2694 }
2695
2696 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2697 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2698 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2699 sd_bus_slot *slot;
2700 int r;
2701
2702 assert(bus);
2703 assert(c);
2704
2705 r = bus_message_new_synthetic_error(
2706 bus,
2707 c->cookie,
2708 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2709 &m);
2710 if (r < 0)
2711 return r;
2712
2713 r = bus_seal_synthetic_message(bus, m);
2714 if (r < 0)
2715 return r;
2716
2717 if (c->timeout_usec != 0) {
2718 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2719 c->timeout_usec = 0;
2720 }
2721
2722 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2723 c->cookie = 0;
2724
2725 slot = container_of(c, sd_bus_slot, reply_callback);
2726
2727 bus->iteration_counter++;
2728
2729 bus->current_message = m;
2730 bus->current_slot = sd_bus_slot_ref(slot);
2731 bus->current_handler = c->callback;
2732 bus->current_userdata = slot->userdata;
2733 r = c->callback(m, slot->userdata, &error_buffer);
2734 bus->current_userdata = NULL;
2735 bus->current_handler = NULL;
2736 bus->current_slot = NULL;
2737 bus->current_message = NULL;
2738
2739 if (slot->floating) {
2740 bus_slot_disconnect(slot);
2741 sd_bus_slot_unref(slot);
2742 }
2743
2744 sd_bus_slot_unref(slot);
2745
2746 return bus_maybe_reply_error(m, r, &error_buffer);
2747 }
2748
2749 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2750 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2751 struct reply_callback *c;
2752 int r;
2753
2754 assert(bus);
2755 assert(bus->state == BUS_CLOSING);
2756
2757 /* First, fail all outstanding method calls */
2758 c = ordered_hashmap_first(bus->reply_callbacks);
2759 if (c)
2760 return process_closing_reply_callback(bus, c);
2761
2762 /* Then, fake-drop all remaining bus tracking references */
2763 if (bus->tracks) {
2764 bus_track_close(bus->tracks);
2765 return 1;
2766 }
2767
2768 /* Then, synthesize a Disconnected message */
2769 r = sd_bus_message_new_signal(
2770 bus,
2771 &m,
2772 "/org/freedesktop/DBus/Local",
2773 "org.freedesktop.DBus.Local",
2774 "Disconnected");
2775 if (r < 0)
2776 return r;
2777
2778 bus_message_set_sender_local(bus, m);
2779
2780 r = bus_seal_synthetic_message(bus, m);
2781 if (r < 0)
2782 return r;
2783
2784 sd_bus_close(bus);
2785
2786 bus->current_message = m;
2787 bus->iteration_counter++;
2788
2789 r = process_filter(bus, m);
2790 if (r != 0)
2791 goto finish;
2792
2793 r = process_match(bus, m);
2794 if (r != 0)
2795 goto finish;
2796
2797 /* Nothing else to do, exit now, if the condition holds */
2798 bus->exit_triggered = true;
2799 (void) bus_exit_now(bus);
2800
2801 if (ret) {
2802 *ret = m;
2803 m = NULL;
2804 }
2805
2806 r = 1;
2807
2808 finish:
2809 bus->current_message = NULL;
2810
2811 return r;
2812 }
2813
2814 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2815 BUS_DONT_DESTROY(bus);
2816 int r;
2817
2818 /* Returns 0 when we didn't do anything. This should cause the
2819 * caller to invoke sd_bus_wait() before returning the next
2820 * time. Returns > 0 when we did something, which possibly
2821 * means *ret is filled in with an unprocessed message. */
2822
2823 assert_return(bus, -EINVAL);
2824 assert_return(!bus_pid_changed(bus), -ECHILD);
2825
2826 /* We don't allow recursively invoking sd_bus_process(). */
2827 assert_return(!bus->current_message, -EBUSY);
2828 assert(!bus->current_slot);
2829
2830 switch (bus->state) {
2831
2832 case BUS_UNSET:
2833 return -ENOTCONN;
2834
2835 case BUS_CLOSED:
2836 return -ECONNRESET;
2837
2838 case BUS_WATCH_BIND:
2839 r = bus_socket_process_watch_bind(bus);
2840 break;
2841
2842 case BUS_OPENING:
2843 r = bus_socket_process_opening(bus);
2844 break;
2845
2846 case BUS_AUTHENTICATING:
2847 r = bus_socket_process_authenticating(bus);
2848 break;
2849
2850 case BUS_RUNNING:
2851 case BUS_HELLO:
2852 r = process_running(bus, hint_priority, priority, ret);
2853 if (r >= 0)
2854 return r;
2855
2856 /* This branch initializes *ret, hence we don't use the generic error checking below */
2857 break;
2858
2859 case BUS_CLOSING:
2860 return process_closing(bus, ret);
2861
2862 default:
2863 assert_not_reached("Unknown state");
2864 }
2865
2866 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2867 bus_enter_closing(bus);
2868 r = 1;
2869 } else if (r < 0)
2870 return r;
2871
2872 if (ret)
2873 *ret = NULL;
2874
2875 return r;
2876 }
2877
2878 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2879 return bus_process_internal(bus, false, 0, ret);
2880 }
2881
2882 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2883 return bus_process_internal(bus, true, priority, ret);
2884 }
2885
2886 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2887 struct pollfd p[2] = {};
2888 int r, n;
2889 struct timespec ts;
2890 usec_t m = USEC_INFINITY;
2891
2892 assert(bus);
2893
2894 if (bus->state == BUS_CLOSING)
2895 return 1;
2896
2897 if (!BUS_IS_OPEN(bus->state))
2898 return -ENOTCONN;
2899
2900 if (bus->state == BUS_WATCH_BIND) {
2901 assert(bus->inotify_fd >= 0);
2902
2903 p[0].events = POLLIN;
2904 p[0].fd = bus->inotify_fd;
2905 n = 1;
2906 } else {
2907 int e;
2908
2909 e = sd_bus_get_events(bus);
2910 if (e < 0)
2911 return e;
2912
2913 if (need_more)
2914 /* The caller really needs some more data, he doesn't
2915 * care about what's already read, or any timeouts
2916 * except its own. */
2917 e |= POLLIN;
2918 else {
2919 usec_t until;
2920 /* The caller wants to process if there's something to
2921 * process, but doesn't care otherwise */
2922
2923 r = sd_bus_get_timeout(bus, &until);
2924 if (r < 0)
2925 return r;
2926 if (r > 0)
2927 m = usec_sub_unsigned(until, now(CLOCK_MONOTONIC));
2928 }
2929
2930 p[0].fd = bus->input_fd;
2931 if (bus->output_fd == bus->input_fd) {
2932 p[0].events = e;
2933 n = 1;
2934 } else {
2935 p[0].events = e & POLLIN;
2936 p[1].fd = bus->output_fd;
2937 p[1].events = e & POLLOUT;
2938 n = 2;
2939 }
2940 }
2941
2942 if (timeout_usec != (uint64_t) -1 && (m == USEC_INFINITY || timeout_usec < m))
2943 m = timeout_usec;
2944
2945 r = ppoll(p, n, m == USEC_INFINITY ? NULL : timespec_store(&ts, m), NULL);
2946 if (r < 0)
2947 return -errno;
2948
2949 return r > 0 ? 1 : 0;
2950 }
2951
2952 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2953
2954 assert_return(bus, -EINVAL);
2955 assert_return(!bus_pid_changed(bus), -ECHILD);
2956
2957 if (bus->state == BUS_CLOSING)
2958 return 0;
2959
2960 if (!BUS_IS_OPEN(bus->state))
2961 return -ENOTCONN;
2962
2963 if (bus->rqueue_size > 0)
2964 return 0;
2965
2966 return bus_poll(bus, false, timeout_usec);
2967 }
2968
2969 _public_ int sd_bus_flush(sd_bus *bus) {
2970 int r;
2971
2972 assert_return(bus, -EINVAL);
2973 assert_return(!bus_pid_changed(bus), -ECHILD);
2974
2975 if (bus->state == BUS_CLOSING)
2976 return 0;
2977
2978 if (!BUS_IS_OPEN(bus->state))
2979 return -ENOTCONN;
2980
2981 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
2982 if (bus->state == BUS_WATCH_BIND)
2983 return -EUNATCH;
2984
2985 r = bus_ensure_running(bus);
2986 if (r < 0)
2987 return r;
2988
2989 if (bus->wqueue_size <= 0)
2990 return 0;
2991
2992 for (;;) {
2993 r = dispatch_wqueue(bus);
2994 if (r < 0) {
2995 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2996 bus_enter_closing(bus);
2997 return -ECONNRESET;
2998 }
2999
3000 return r;
3001 }
3002
3003 if (bus->wqueue_size <= 0)
3004 return 0;
3005
3006 r = bus_poll(bus, false, (uint64_t) -1);
3007 if (r < 0)
3008 return r;
3009 }
3010 }
3011
3012 _public_ int sd_bus_add_filter(
3013 sd_bus *bus,
3014 sd_bus_slot **slot,
3015 sd_bus_message_handler_t callback,
3016 void *userdata) {
3017
3018 sd_bus_slot *s;
3019
3020 assert_return(bus, -EINVAL);
3021 assert_return(callback, -EINVAL);
3022 assert_return(!bus_pid_changed(bus), -ECHILD);
3023
3024 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
3025 if (!s)
3026 return -ENOMEM;
3027
3028 s->filter_callback.callback = callback;
3029
3030 bus->filter_callbacks_modified = true;
3031 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
3032
3033 if (slot)
3034 *slot = s;
3035
3036 return 0;
3037 }
3038
3039 static int add_match_callback(
3040 sd_bus_message *m,
3041 void *userdata,
3042 sd_bus_error *ret_error) {
3043
3044 sd_bus_slot *match_slot = userdata;
3045 bool failed = false;
3046 int r;
3047
3048 assert(m);
3049 assert(match_slot);
3050
3051 sd_bus_slot_ref(match_slot);
3052
3053 if (sd_bus_message_is_method_error(m, NULL)) {
3054 log_debug_errno(sd_bus_message_get_errno(m),
3055 "Unable to add match %s, failing connection: %s",
3056 match_slot->match_callback.match_string,
3057 sd_bus_message_get_error(m)->message);
3058
3059 failed = true;
3060 } else
3061 log_debug("Match %s successfully installed.", match_slot->match_callback.match_string);
3062
3063 if (match_slot->match_callback.install_callback) {
3064 sd_bus *bus;
3065
3066 bus = sd_bus_message_get_bus(m);
3067
3068 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3069 * update the slot callback metadata temporarily with our own data, and then revert back to the old
3070 * values. */
3071
3072 assert(bus->current_slot == match_slot->match_callback.install_slot);
3073 assert(bus->current_handler == add_match_callback);
3074 assert(bus->current_userdata == userdata);
3075
3076 bus->current_slot = match_slot;
3077 bus->current_handler = match_slot->match_callback.install_callback;
3078 bus->current_userdata = match_slot->userdata;
3079
3080 r = match_slot->match_callback.install_callback(m, match_slot->userdata, ret_error);
3081
3082 bus->current_slot = match_slot->match_callback.install_slot;
3083 bus->current_handler = add_match_callback;
3084 bus->current_userdata = userdata;
3085
3086 match_slot->match_callback.install_slot = sd_bus_slot_unref(match_slot->match_callback.install_slot);
3087 } else {
3088 if (failed) /* Generic failure handling: destroy the connection */
3089 bus_enter_closing(sd_bus_message_get_bus(m));
3090
3091 r = 1;
3092 }
3093
3094 if (failed && match_slot->floating) {
3095 bus_slot_disconnect(match_slot);
3096 sd_bus_slot_unref(match_slot);
3097 }
3098
3099 sd_bus_slot_unref(match_slot);
3100
3101 return r;
3102 }
3103
3104 static int bus_add_match_full(
3105 sd_bus *bus,
3106 sd_bus_slot **slot,
3107 bool asynchronous,
3108 const char *match,
3109 sd_bus_message_handler_t callback,
3110 sd_bus_message_handler_t install_callback,
3111 void *userdata) {
3112
3113 struct bus_match_component *components = NULL;
3114 unsigned n_components = 0;
3115 sd_bus_slot *s = NULL;
3116 int r = 0;
3117
3118 assert_return(bus, -EINVAL);
3119 assert_return(match, -EINVAL);
3120 assert_return(!bus_pid_changed(bus), -ECHILD);
3121
3122 r = bus_match_parse(match, &components, &n_components);
3123 if (r < 0)
3124 goto finish;
3125
3126 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3127 if (!s) {
3128 r = -ENOMEM;
3129 goto finish;
3130 }
3131
3132 s->match_callback.callback = callback;
3133 s->match_callback.install_callback = install_callback;
3134
3135 if (bus->bus_client) {
3136 enum bus_match_scope scope;
3137
3138 scope = bus_match_get_scope(components, n_components);
3139
3140 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3141 if (scope != BUS_MATCH_LOCAL) {
3142
3143 /* We store the original match string, so that we can use it to remove the match again. */
3144
3145 s->match_callback.match_string = strdup(match);
3146 if (!s->match_callback.match_string) {
3147 r = -ENOMEM;
3148 goto finish;
3149 }
3150
3151 if (asynchronous)
3152 r = bus_add_match_internal_async(bus,
3153 &s->match_callback.install_slot,
3154 s->match_callback.match_string,
3155 add_match_callback,
3156 s);
3157 else
3158 r = bus_add_match_internal(bus, s->match_callback.match_string);
3159 if (r < 0)
3160 goto finish;
3161
3162 s->match_added = true;
3163 }
3164 }
3165
3166 bus->match_callbacks_modified = true;
3167 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3168 if (r < 0)
3169 goto finish;
3170
3171 if (slot)
3172 *slot = s;
3173 s = NULL;
3174
3175 finish:
3176 bus_match_parse_free(components, n_components);
3177 sd_bus_slot_unref(s);
3178
3179 return r;
3180 }
3181
3182 _public_ int sd_bus_add_match(
3183 sd_bus *bus,
3184 sd_bus_slot **slot,
3185 const char *match,
3186 sd_bus_message_handler_t callback,
3187 void *userdata) {
3188
3189 return bus_add_match_full(bus, slot, false, match, callback, NULL, userdata);
3190 }
3191
3192 _public_ int sd_bus_add_match_async(
3193 sd_bus *bus,
3194 sd_bus_slot **slot,
3195 const char *match,
3196 sd_bus_message_handler_t callback,
3197 sd_bus_message_handler_t install_callback,
3198 void *userdata) {
3199
3200 return bus_add_match_full(bus, slot, true, match, callback, install_callback, userdata);
3201 }
3202
3203 bool bus_pid_changed(sd_bus *bus) {
3204 assert(bus);
3205
3206 /* We don't support people creating a bus connection and
3207 * keeping it around over a fork(). Let's complain. */
3208
3209 return bus->original_pid != getpid_cached();
3210 }
3211
3212 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3213 sd_bus *bus = userdata;
3214 int r;
3215
3216 assert(bus);
3217
3218 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3219
3220 r = sd_bus_process(bus, NULL);
3221 if (r < 0) {
3222 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3223 bus_enter_closing(bus);
3224 }
3225
3226 return 1;
3227 }
3228
3229 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3230 sd_bus *bus = userdata;
3231 int r;
3232
3233 assert(bus);
3234
3235 r = sd_bus_process(bus, NULL);
3236 if (r < 0) {
3237 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3238 bus_enter_closing(bus);
3239 }
3240
3241 return 1;
3242 }
3243
3244 static int prepare_callback(sd_event_source *s, void *userdata) {
3245 sd_bus *bus = userdata;
3246 int r, e;
3247 usec_t until;
3248
3249 assert(s);
3250 assert(bus);
3251
3252 e = sd_bus_get_events(bus);
3253 if (e < 0) {
3254 r = e;
3255 goto fail;
3256 }
3257
3258 if (bus->output_fd != bus->input_fd) {
3259
3260 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3261 if (r < 0)
3262 goto fail;
3263
3264 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3265 } else
3266 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3267 if (r < 0)
3268 goto fail;
3269
3270 r = sd_bus_get_timeout(bus, &until);
3271 if (r < 0)
3272 goto fail;
3273 if (r > 0) {
3274 int j;
3275
3276 j = sd_event_source_set_time(bus->time_event_source, until);
3277 if (j < 0) {
3278 r = j;
3279 goto fail;
3280 }
3281 }
3282
3283 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3284 if (r < 0)
3285 goto fail;
3286
3287 return 1;
3288
3289 fail:
3290 log_debug_errno(r, "Preparing of bus events failed, closing down: %m");
3291 bus_enter_closing(bus);
3292
3293 return 1;
3294 }
3295
3296 static int quit_callback(sd_event_source *event, void *userdata) {
3297 sd_bus *bus = userdata;
3298
3299 assert(event);
3300
3301 sd_bus_flush(bus);
3302 sd_bus_close(bus);
3303
3304 return 1;
3305 }
3306
3307 int bus_attach_io_events(sd_bus *bus) {
3308 int r;
3309
3310 assert(bus);
3311
3312 if (bus->input_fd < 0)
3313 return 0;
3314
3315 if (!bus->event)
3316 return 0;
3317
3318 if (!bus->input_io_event_source) {
3319 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3320 if (r < 0)
3321 return r;
3322
3323 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3324 if (r < 0)
3325 return r;
3326
3327 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3328 if (r < 0)
3329 return r;
3330
3331 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3332 } else
3333 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3334
3335 if (r < 0)
3336 return r;
3337
3338 if (bus->output_fd != bus->input_fd) {
3339 assert(bus->output_fd >= 0);
3340
3341 if (!bus->output_io_event_source) {
3342 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3343 if (r < 0)
3344 return r;
3345
3346 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3347 if (r < 0)
3348 return r;
3349
3350 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3351 } else
3352 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3353
3354 if (r < 0)
3355 return r;
3356 }
3357
3358 return 0;
3359 }
3360
3361 static void bus_detach_io_events(sd_bus *bus) {
3362 assert(bus);
3363
3364 if (bus->input_io_event_source) {
3365 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3366 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3367 }
3368
3369 if (bus->output_io_event_source) {
3370 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3371 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3372 }
3373 }
3374
3375 int bus_attach_inotify_event(sd_bus *bus) {
3376 int r;
3377
3378 assert(bus);
3379
3380 if (bus->inotify_fd < 0)
3381 return 0;
3382
3383 if (!bus->event)
3384 return 0;
3385
3386 if (!bus->inotify_event_source) {
3387 r = sd_event_add_io(bus->event, &bus->inotify_event_source, bus->inotify_fd, EPOLLIN, io_callback, bus);
3388 if (r < 0)
3389 return r;
3390
3391 r = sd_event_source_set_priority(bus->inotify_event_source, bus->event_priority);
3392 if (r < 0)
3393 return r;
3394
3395 r = sd_event_source_set_description(bus->inotify_event_source, "bus-inotify");
3396 } else
3397 r = sd_event_source_set_io_fd(bus->inotify_event_source, bus->inotify_fd);
3398 if (r < 0)
3399 return r;
3400
3401 return 0;
3402 }
3403
3404 static void bus_detach_inotify_event(sd_bus *bus) {
3405 assert(bus);
3406
3407 if (bus->inotify_event_source) {
3408 sd_event_source_set_enabled(bus->inotify_event_source, SD_EVENT_OFF);
3409 bus->inotify_event_source = sd_event_source_unref(bus->inotify_event_source);
3410 }
3411 }
3412
3413 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3414 int r;
3415
3416 assert_return(bus, -EINVAL);
3417 assert_return(!bus->event, -EBUSY);
3418
3419 assert(!bus->input_io_event_source);
3420 assert(!bus->output_io_event_source);
3421 assert(!bus->time_event_source);
3422
3423 if (event)
3424 bus->event = sd_event_ref(event);
3425 else {
3426 r = sd_event_default(&bus->event);
3427 if (r < 0)
3428 return r;
3429 }
3430
3431 bus->event_priority = priority;
3432
3433 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3434 if (r < 0)
3435 goto fail;
3436
3437 r = sd_event_source_set_priority(bus->time_event_source, priority);
3438 if (r < 0)
3439 goto fail;
3440
3441 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3442 if (r < 0)
3443 goto fail;
3444
3445 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3446 if (r < 0)
3447 goto fail;
3448
3449 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3450 if (r < 0)
3451 goto fail;
3452
3453 r = bus_attach_io_events(bus);
3454 if (r < 0)
3455 goto fail;
3456
3457 r = bus_attach_inotify_event(bus);
3458 if (r < 0)
3459 goto fail;
3460
3461 return 0;
3462
3463 fail:
3464 sd_bus_detach_event(bus);
3465 return r;
3466 }
3467
3468 _public_ int sd_bus_detach_event(sd_bus *bus) {
3469 assert_return(bus, -EINVAL);
3470
3471 if (!bus->event)
3472 return 0;
3473
3474 bus_detach_io_events(bus);
3475 bus_detach_inotify_event(bus);
3476
3477 if (bus->time_event_source) {
3478 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3479 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3480 }
3481
3482 if (bus->quit_event_source) {
3483 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3484 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3485 }
3486
3487 bus->event = sd_event_unref(bus->event);
3488 return 1;
3489 }
3490
3491 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3492 assert_return(bus, NULL);
3493
3494 return bus->event;
3495 }
3496
3497 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3498 assert_return(bus, NULL);
3499
3500 return bus->current_message;
3501 }
3502
3503 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3504 assert_return(bus, NULL);
3505
3506 return bus->current_slot;
3507 }
3508
3509 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3510 assert_return(bus, NULL);
3511
3512 return bus->current_handler;
3513 }
3514
3515 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3516 assert_return(bus, NULL);
3517
3518 return bus->current_userdata;
3519 }
3520
3521 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3522 sd_bus *b = NULL;
3523 int r;
3524
3525 assert(bus_open);
3526 assert(default_bus);
3527
3528 if (!ret)
3529 return !!*default_bus;
3530
3531 if (*default_bus) {
3532 *ret = sd_bus_ref(*default_bus);
3533 return 0;
3534 }
3535
3536 r = bus_open(&b);
3537 if (r < 0)
3538 return r;
3539
3540 b->default_bus_ptr = default_bus;
3541 b->tid = gettid();
3542 *default_bus = b;
3543
3544 *ret = b;
3545 return 1;
3546 }
3547
3548 _public_ int sd_bus_default_system(sd_bus **ret) {
3549 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3550 }
3551
3552
3553 _public_ int sd_bus_default_user(sd_bus **ret) {
3554 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3555 }
3556
3557 _public_ int sd_bus_default(sd_bus **ret) {
3558
3559 const char *e;
3560
3561 /* Let's try our best to reuse another cached connection. If
3562 * the starter bus type is set, connect via our normal
3563 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3564 * we can share the connection with the user/system default
3565 * bus. */
3566
3567 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3568 if (e) {
3569 if (streq(e, "system"))
3570 return sd_bus_default_system(ret);
3571 else if (STR_IN_SET(e, "user", "session"))
3572 return sd_bus_default_user(ret);
3573 }
3574
3575 /* No type is specified, so we have not other option than to
3576 * use the starter address if it is set. */
3577 e = secure_getenv("DBUS_STARTER_ADDRESS");
3578 if (e)
3579 return bus_default(sd_bus_open, &default_starter_bus, ret);
3580
3581 /* Finally, if nothing is set use the cached connection for
3582 * the right scope */
3583
3584 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3585 return sd_bus_default_user(ret);
3586 else
3587 return sd_bus_default_system(ret);
3588 }
3589
3590 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3591 assert_return(b, -EINVAL);
3592 assert_return(tid, -EINVAL);
3593 assert_return(!bus_pid_changed(b), -ECHILD);
3594
3595 if (b->tid != 0) {
3596 *tid = b->tid;
3597 return 0;
3598 }
3599
3600 if (b->event)
3601 return sd_event_get_tid(b->event, tid);
3602
3603 return -ENXIO;
3604 }
3605
3606 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3607 _cleanup_free_ char *e = NULL;
3608 char *ret;
3609
3610 assert_return(object_path_is_valid(prefix), -EINVAL);
3611 assert_return(external_id, -EINVAL);
3612 assert_return(ret_path, -EINVAL);
3613
3614 e = bus_label_escape(external_id);
3615 if (!e)
3616 return -ENOMEM;
3617
3618 ret = strjoin(prefix, "/", e);
3619 if (!ret)
3620 return -ENOMEM;
3621
3622 *ret_path = ret;
3623 return 0;
3624 }
3625
3626 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3627 const char *e;
3628 char *ret;
3629
3630 assert_return(object_path_is_valid(path), -EINVAL);
3631 assert_return(object_path_is_valid(prefix), -EINVAL);
3632 assert_return(external_id, -EINVAL);
3633
3634 e = object_path_startswith(path, prefix);
3635 if (!e) {
3636 *external_id = NULL;
3637 return 0;
3638 }
3639
3640 ret = bus_label_unescape(e);
3641 if (!ret)
3642 return -ENOMEM;
3643
3644 *external_id = ret;
3645 return 1;
3646 }
3647
3648 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3649 _cleanup_strv_free_ char **labels = NULL;
3650 char *path, *path_pos, **label_pos;
3651 const char *sep, *template_pos;
3652 size_t path_length;
3653 va_list list;
3654 int r;
3655
3656 assert_return(out, -EINVAL);
3657 assert_return(path_template, -EINVAL);
3658
3659 path_length = strlen(path_template);
3660
3661 va_start(list, path_template);
3662 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3663 const char *arg;
3664 char *label;
3665
3666 arg = va_arg(list, const char *);
3667 if (!arg) {
3668 va_end(list);
3669 return -EINVAL;
3670 }
3671
3672 label = bus_label_escape(arg);
3673 if (!label) {
3674 va_end(list);
3675 return -ENOMEM;
3676 }
3677
3678 r = strv_consume(&labels, label);
3679 if (r < 0) {
3680 va_end(list);
3681 return r;
3682 }
3683
3684 /* add label length, but account for the format character */
3685 path_length += strlen(label) - 1;
3686 }
3687 va_end(list);
3688
3689 path = malloc(path_length + 1);
3690 if (!path)
3691 return -ENOMEM;
3692
3693 path_pos = path;
3694 label_pos = labels;
3695
3696 for (template_pos = path_template; *template_pos; ) {
3697 sep = strchrnul(template_pos, '%');
3698 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3699 if (!*sep)
3700 break;
3701
3702 path_pos = stpcpy(path_pos, *label_pos++);
3703 template_pos = sep + 1;
3704 }
3705
3706 *path_pos = 0;
3707 *out = path;
3708 return 0;
3709 }
3710
3711 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3712 _cleanup_strv_free_ char **labels = NULL;
3713 const char *template_pos, *path_pos;
3714 char **label_pos;
3715 va_list list;
3716 int r;
3717
3718 /*
3719 * This decodes an object-path based on a template argument. The
3720 * template consists of a verbatim path, optionally including special
3721 * directives:
3722 *
3723 * - Each occurrence of '%' in the template matches an arbitrary
3724 * substring of a label in the given path. At most one such
3725 * directive is allowed per label. For each such directive, the
3726 * caller must provide an output parameter (char **) via va_arg. If
3727 * NULL is passed, the given label is verified, but not returned.
3728 * For each matched label, the *decoded* label is stored in the
3729 * passed output argument, and the caller is responsible to free
3730 * it. Note that the output arguments are only modified if the
3731 * actualy path matched the template. Otherwise, they're left
3732 * untouched.
3733 *
3734 * This function returns <0 on error, 0 if the path does not match the
3735 * template, 1 if it matched.
3736 */
3737
3738 assert_return(path, -EINVAL);
3739 assert_return(path_template, -EINVAL);
3740
3741 path_pos = path;
3742
3743 for (template_pos = path_template; *template_pos; ) {
3744 const char *sep;
3745 size_t length;
3746 char *label;
3747
3748 /* verify everything until the next '%' matches verbatim */
3749 sep = strchrnul(template_pos, '%');
3750 length = sep - template_pos;
3751 if (strncmp(path_pos, template_pos, length))
3752 return 0;
3753
3754 path_pos += length;
3755 template_pos += length;
3756
3757 if (!*template_pos)
3758 break;
3759
3760 /* We found the next '%' character. Everything up until here
3761 * matched. We now skip ahead to the end of this label and make
3762 * sure it matches the tail of the label in the path. Then we
3763 * decode the string in-between and save it for later use. */
3764
3765 ++template_pos; /* skip over '%' */
3766
3767 sep = strchrnul(template_pos, '/');
3768 length = sep - template_pos; /* length of suffix to match verbatim */
3769
3770 /* verify the suffixes match */
3771 sep = strchrnul(path_pos, '/');
3772 if (sep - path_pos < (ssize_t)length ||
3773 strncmp(sep - length, template_pos, length))
3774 return 0;
3775
3776 template_pos += length; /* skip over matched label */
3777 length = sep - path_pos - length; /* length of sub-label to decode */
3778
3779 /* store unescaped label for later use */
3780 label = bus_label_unescape_n(path_pos, length);
3781 if (!label)
3782 return -ENOMEM;
3783
3784 r = strv_consume(&labels, label);
3785 if (r < 0)
3786 return r;
3787
3788 path_pos = sep; /* skip decoded label and suffix */
3789 }
3790
3791 /* end of template must match end of path */
3792 if (*path_pos)
3793 return 0;
3794
3795 /* copy the labels over to the caller */
3796 va_start(list, path_template);
3797 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3798 char **arg;
3799
3800 arg = va_arg(list, char **);
3801 if (arg)
3802 *arg = *label_pos;
3803 else
3804 free(*label_pos);
3805 }
3806 va_end(list);
3807
3808 labels = mfree(labels);
3809 return 1;
3810 }
3811
3812 _public_ int sd_bus_try_close(sd_bus *bus) {
3813 assert_return(bus, -EINVAL);
3814 assert_return(!bus_pid_changed(bus), -ECHILD);
3815
3816 return -EOPNOTSUPP;
3817 }
3818
3819 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3820 assert_return(bus, -EINVAL);
3821 assert_return(description, -EINVAL);
3822 assert_return(bus->description, -ENXIO);
3823 assert_return(!bus_pid_changed(bus), -ECHILD);
3824
3825 *description = bus->description;
3826 return 0;
3827 }
3828
3829 int bus_get_root_path(sd_bus *bus) {
3830 int r;
3831
3832 if (bus->cgroup_root)
3833 return 0;
3834
3835 r = cg_get_root_path(&bus->cgroup_root);
3836 if (r == -ENOENT) {
3837 bus->cgroup_root = strdup("/");
3838 if (!bus->cgroup_root)
3839 return -ENOMEM;
3840
3841 r = 0;
3842 }
3843
3844 return r;
3845 }
3846
3847 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3848 assert_return(bus, -EINVAL);
3849 assert_return(scope, -EINVAL);
3850 assert_return(!bus_pid_changed(bus), -ECHILD);
3851
3852 if (bus->is_user) {
3853 *scope = "user";
3854 return 0;
3855 }
3856
3857 if (bus->is_system) {
3858 *scope = "system";
3859 return 0;
3860 }
3861
3862 return -ENODATA;
3863 }
3864
3865 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3866
3867 assert_return(bus, -EINVAL);
3868 assert_return(address, -EINVAL);
3869 assert_return(!bus_pid_changed(bus), -ECHILD);
3870
3871 if (bus->address) {
3872 *address = bus->address;
3873 return 0;
3874 }
3875
3876 return -ENODATA;
3877 }
3878
3879 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3880 assert_return(bus, -EINVAL);
3881 assert_return(mask, -EINVAL);
3882 assert_return(!bus_pid_changed(bus), -ECHILD);
3883
3884 *mask = bus->creds_mask;
3885 return 0;
3886 }
3887
3888 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3889 assert_return(bus, -EINVAL);
3890 assert_return(!bus_pid_changed(bus), -ECHILD);
3891
3892 return bus->bus_client;
3893 }
3894
3895 _public_ int sd_bus_is_server(sd_bus *bus) {
3896 assert_return(bus, -EINVAL);
3897 assert_return(!bus_pid_changed(bus), -ECHILD);
3898
3899 return bus->is_server;
3900 }
3901
3902 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3903 assert_return(bus, -EINVAL);
3904 assert_return(!bus_pid_changed(bus), -ECHILD);
3905
3906 return bus->anonymous_auth;
3907 }
3908
3909 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3910 assert_return(bus, -EINVAL);
3911 assert_return(!bus_pid_changed(bus), -ECHILD);
3912
3913 return bus->trusted;
3914 }
3915
3916 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3917 assert_return(bus, -EINVAL);
3918 assert_return(!bus_pid_changed(bus), -ECHILD);
3919
3920 return bus->is_monitor;
3921 }
3922
3923 static void flush_close(sd_bus *bus) {
3924 if (!bus)
3925 return;
3926
3927 /* Flushes and closes the specified bus. We take a ref before,
3928 * to ensure the flushing does not cause the bus to be
3929 * unreferenced. */
3930
3931 sd_bus_flush_close_unref(sd_bus_ref(bus));
3932 }
3933
3934 _public_ void sd_bus_default_flush_close(void) {
3935 flush_close(default_starter_bus);
3936 flush_close(default_user_bus);
3937 flush_close(default_system_bus);
3938 }
3939
3940 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
3941 assert_return(bus, -EINVAL);
3942
3943 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
3944 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
3945 * from the client side. */
3946 bus->exit_on_disconnect = b;
3947
3948 /* If the exit condition was triggered already, exit immediately. */
3949 return bus_exit_now(bus);
3950 }
3951
3952 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
3953 assert_return(bus, -EINVAL);
3954
3955 return bus->exit_on_disconnect;
3956 }
Unnamed repository; edit this file 'description' to name the repository.