1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
35 #include "cgroup-util.h"
36 #include "bus-label.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
42 #include "bus-socket.h"
43 #include "bus-kernel.h"
44 #include "bus-control.h"
45 #include "bus-objects.h"
47 #include "bus-container.h"
48 #include "bus-protocol.h"
49 #include "bus-track.h"
52 #define log_debug_bus_message(m) \
54 sd_bus_message *_mm = (m); \
55 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
56 bus_message_type_to_string(_mm->header->type), \
57 strna(sd_bus_message_get_sender(_mm)), \
58 strna(sd_bus_message_get_destination(_mm)), \
59 strna(sd_bus_message_get_path(_mm)), \
60 strna(sd_bus_message_get_interface(_mm)), \
61 strna(sd_bus_message_get_member(_mm)), \
62 BUS_MESSAGE_COOKIE(_mm), \
64 strna(_mm->error.message)); \
67 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
68 static int attach_io_events(sd_bus *b);
69 static void detach_io_events(sd_bus *b);
71 static void bus_close_fds(sd_bus *b) {
77 safe_close(b->input_fd);
79 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
80 safe_close(b->output_fd);
82 b->input_fd = b->output_fd = -1;
85 static void bus_reset_queues(sd_bus *b) {
88 while (b->rqueue_size > 0)
89 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
93 b->rqueue_allocated = 0;
95 while (b->wqueue_size > 0)
96 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
100 b->wqueue_allocated = 0;
103 static void bus_free(sd_bus *b) {
107 assert(!b->track_queue);
109 b->state = BUS_CLOSED;
111 sd_bus_detach_event(b);
113 while ((s = b->slots)) {
114 /* At this point only floating slots can still be
115 * around, because the non-floating ones keep a
116 * reference to the bus, and we thus couldn't be
117 * destructing right now... We forcibly disconnect the
118 * slots here, so that they still can be referenced by
119 * apps, but are dead. */
122 bus_slot_disconnect(s);
123 sd_bus_slot_unref(s);
126 if (b->default_bus_ptr)
127 *b->default_bus_ptr = NULL;
132 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
136 free(b->unique_name);
137 free(b->auth_buffer);
142 free(b->cgroup_root);
143 free(b->description);
146 strv_free(b->exec_argv);
148 close_many(b->fds, b->n_fds);
153 ordered_hashmap_free_free(b->reply_callbacks);
154 prioq_free(b->reply_callbacks_prioq);
156 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
157 bus_match_free(&b->match_callbacks);
159 hashmap_free_free(b->vtable_methods);
160 hashmap_free_free(b->vtable_properties);
162 assert(hashmap_isempty(b->nodes));
163 hashmap_free(b->nodes);
165 bus_kernel_flush_memfd(b);
167 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
172 _public_ int sd_bus_new(sd_bus **ret) {
175 assert_return(ret, -EINVAL);
181 r->n_ref = REFCNT_INIT;
182 r->input_fd = r->output_fd = -1;
183 r->message_version = 1;
184 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
185 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
186 r->attach_flags |= KDBUS_ATTACH_NAMES;
187 r->original_pid = getpid();
189 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
191 /* We guarantee that wqueue always has space for at least one
193 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
202 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
205 assert_return(bus, -EINVAL);
206 assert_return(bus->state == BUS_UNSET, -EPERM);
207 assert_return(address, -EINVAL);
208 assert_return(!bus_pid_changed(bus), -ECHILD);
220 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
221 assert_return(bus, -EINVAL);
222 assert_return(bus->state == BUS_UNSET, -EPERM);
223 assert_return(input_fd >= 0, -EINVAL);
224 assert_return(output_fd >= 0, -EINVAL);
225 assert_return(!bus_pid_changed(bus), -ECHILD);
227 bus->input_fd = input_fd;
228 bus->output_fd = output_fd;
232 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
235 assert_return(bus, -EINVAL);
236 assert_return(bus->state == BUS_UNSET, -EPERM);
237 assert_return(path, -EINVAL);
238 assert_return(!strv_isempty(argv), -EINVAL);
239 assert_return(!bus_pid_changed(bus), -ECHILD);
251 free(bus->exec_path);
252 strv_free(bus->exec_argv);
260 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
261 assert_return(bus, -EINVAL);
262 assert_return(bus->state == BUS_UNSET, -EPERM);
263 assert_return(!bus_pid_changed(bus), -ECHILD);
265 bus->bus_client = !!b;
269 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
270 assert_return(bus, -EINVAL);
271 assert_return(bus->state == BUS_UNSET, -EPERM);
272 assert_return(!bus_pid_changed(bus), -ECHILD);
274 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
278 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
279 assert_return(bus, -EINVAL);
280 assert_return(bus->state == BUS_UNSET, -EPERM);
281 assert_return(!bus_pid_changed(bus), -ECHILD);
283 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
287 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
289 assert_return(bus, -EINVAL);
290 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
291 assert_return(!bus_pid_changed(bus), -ECHILD);
293 new_flags = bus->attach_flags;
294 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
296 if (bus->attach_flags == new_flags)
299 bus->attach_flags = new_flags;
300 if (bus->state != BUS_UNSET && bus->is_kernel)
301 bus_kernel_realize_attach_flags(bus);
306 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
309 assert_return(bus, -EINVAL);
310 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
311 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
312 assert_return(!bus_pid_changed(bus), -ECHILD);
315 bus->creds_mask |= mask;
317 bus->creds_mask &= ~mask;
319 /* The well knowns we need unconditionally, so that matches can work */
320 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
322 /* Make sure we don't lose the timestamp flag */
323 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
324 if (bus->attach_flags == new_flags)
327 bus->attach_flags = new_flags;
328 if (bus->state != BUS_UNSET && bus->is_kernel)
329 bus_kernel_realize_attach_flags(bus);
334 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
335 assert_return(bus, -EINVAL);
336 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
337 assert_return(bus->state == BUS_UNSET, -EPERM);
338 assert_return(!bus_pid_changed(bus), -ECHILD);
340 bus->is_server = !!b;
341 bus->server_id = server_id;
345 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
346 assert_return(bus, -EINVAL);
347 assert_return(bus->state == BUS_UNSET, -EPERM);
348 assert_return(!bus_pid_changed(bus), -ECHILD);
350 bus->anonymous_auth = !!b;
354 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
355 assert_return(bus, -EINVAL);
356 assert_return(bus->state == BUS_UNSET, -EPERM);
357 assert_return(!bus_pid_changed(bus), -ECHILD);
363 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
364 assert_return(bus, -EINVAL);
365 assert_return(bus->state == BUS_UNSET, -EPERM);
366 assert_return(!bus_pid_changed(bus), -ECHILD);
368 return free_and_strdup(&bus->description, description);
371 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
372 assert_return(bus, -EINVAL);
373 assert_return(!bus_pid_changed(bus), -ECHILD);
375 bus->allow_interactive_authorization = !!b;
379 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
380 assert_return(bus, -EINVAL);
381 assert_return(!bus_pid_changed(bus), -ECHILD);
383 return bus->allow_interactive_authorization;
386 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
394 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
396 r = sd_bus_message_get_errno(reply);
400 r = sd_bus_message_read(reply, "s", &s);
404 if (!service_name_is_valid(s) || s[0] != ':')
407 bus->unique_name = strdup(s);
408 if (!bus->unique_name)
411 if (bus->state == BUS_HELLO)
412 bus->state = BUS_RUNNING;
417 static int bus_send_hello(sd_bus *bus) {
418 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
423 if (!bus->bus_client || bus->is_kernel)
426 r = sd_bus_message_new_method_call(
429 "org.freedesktop.DBus",
430 "/org/freedesktop/DBus",
431 "org.freedesktop.DBus",
436 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
439 int bus_start_running(sd_bus *bus) {
442 if (bus->bus_client && !bus->is_kernel) {
443 bus->state = BUS_HELLO;
447 bus->state = BUS_RUNNING;
451 static int parse_address_key(const char **p, const char *key, char **value) {
452 size_t l, n = 0, allocated = 0;
462 if (strncmp(*p, key, l) != 0)
475 while (*a != ';' && *a != ',' && *a != 0) {
493 c = (char) ((x << 4) | y);
500 if (!GREEDY_REALLOC(r, allocated, n + 2))
524 static void skip_address_key(const char **p) {
528 *p += strcspn(*p, ",");
534 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
535 _cleanup_free_ char *path = NULL, *abstract = NULL;
544 while (**p != 0 && **p != ';') {
545 r = parse_address_key(p, "guid", guid);
551 r = parse_address_key(p, "path", &path);
557 r = parse_address_key(p, "abstract", &abstract);
566 if (!path && !abstract)
569 if (path && abstract)
574 if (l > sizeof(b->sockaddr.un.sun_path))
577 b->sockaddr.un.sun_family = AF_UNIX;
578 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
579 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
580 } else if (abstract) {
581 l = strlen(abstract);
582 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
585 b->sockaddr.un.sun_family = AF_UNIX;
586 b->sockaddr.un.sun_path[0] = 0;
587 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
588 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
594 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
595 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
597 struct addrinfo *result, hints = {
598 .ai_socktype = SOCK_STREAM,
599 .ai_flags = AI_ADDRCONFIG,
607 while (**p != 0 && **p != ';') {
608 r = parse_address_key(p, "guid", guid);
614 r = parse_address_key(p, "host", &host);
620 r = parse_address_key(p, "port", &port);
626 r = parse_address_key(p, "family", &family);
639 if (streq(family, "ipv4"))
640 hints.ai_family = AF_INET;
641 else if (streq(family, "ipv6"))
642 hints.ai_family = AF_INET6;
647 r = getaddrinfo(host, port, &hints, &result);
651 return -EADDRNOTAVAIL;
653 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
654 b->sockaddr_size = result->ai_addrlen;
656 freeaddrinfo(result);
661 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
663 unsigned n_argv = 0, j;
665 size_t allocated = 0;
673 while (**p != 0 && **p != ';') {
674 r = parse_address_key(p, "guid", guid);
680 r = parse_address_key(p, "path", &path);
686 if (startswith(*p, "argv")) {
690 ul = strtoul(*p + 4, (char**) p, 10);
691 if (errno > 0 || **p != '=' || ul > 256) {
699 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
707 r = parse_address_key(p, NULL, argv + ul);
722 /* Make sure there are no holes in the array, with the
723 * exception of argv[0] */
724 for (j = 1; j < n_argv; j++)
730 if (argv && argv[0] == NULL) {
731 argv[0] = strdup(path);
743 for (j = 0; j < n_argv; j++)
751 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
752 _cleanup_free_ char *path = NULL;
760 while (**p != 0 && **p != ';') {
761 r = parse_address_key(p, "guid", guid);
767 r = parse_address_key(p, "path", &path);
786 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
787 _cleanup_free_ char *machine = NULL, *pid = NULL;
795 while (**p != 0 && **p != ';') {
796 r = parse_address_key(p, "guid", guid);
802 r = parse_address_key(p, "machine", &machine);
808 r = parse_address_key(p, "pid", &pid);
817 if (!machine == !pid)
821 if (!machine_name_is_valid(machine))
825 b->machine = machine;
833 r = parse_pid(pid, &b->nspid);
839 b->sockaddr.un.sun_family = AF_UNIX;
840 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
841 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
846 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
847 _cleanup_free_ char *machine = NULL, *pid = NULL;
855 while (**p != 0 && **p != ';') {
856 r = parse_address_key(p, "guid", guid);
862 r = parse_address_key(p, "machine", &machine);
868 r = parse_address_key(p, "pid", &pid);
877 if (!machine == !pid)
881 if (!machine_name_is_valid(machine))
885 b->machine = machine;
893 r = parse_pid(pid, &b->nspid);
900 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
907 static void bus_reset_parsed_address(sd_bus *b) {
911 b->sockaddr_size = 0;
912 strv_free(b->exec_argv);
916 b->server_id = SD_ID128_NULL;
924 static int bus_parse_next_address(sd_bus *b) {
925 _cleanup_free_ char *guid = NULL;
933 if (b->address[b->address_index] == 0)
936 bus_reset_parsed_address(b);
938 a = b->address + b->address_index;
947 if (startswith(a, "unix:")) {
950 r = parse_unix_address(b, &a, &guid);
955 } else if (startswith(a, "tcp:")) {
958 r = parse_tcp_address(b, &a, &guid);
964 } else if (startswith(a, "unixexec:")) {
967 r = parse_exec_address(b, &a, &guid);
973 } else if (startswith(a, "kernel:")) {
976 r = parse_kernel_address(b, &a, &guid);
981 } else if (startswith(a, "x-machine-unix:")) {
984 r = parse_container_unix_address(b, &a, &guid);
989 } else if (startswith(a, "x-machine-kernel:")) {
992 r = parse_container_kernel_address(b, &a, &guid);
1005 r = sd_id128_from_string(guid, &b->server_id);
1010 b->address_index = a - b->address;
1014 static int bus_start_address(sd_bus *b) {
1020 bool skipped = false;
1025 r = bus_socket_exec(b);
1026 else if ((b->nspid > 0 || b->machine) && b->kernel)
1027 r = bus_container_connect_kernel(b);
1028 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1029 r = bus_container_connect_socket(b);
1031 r = bus_kernel_connect(b);
1032 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1033 r = bus_socket_connect(b);
1039 r = attach_io_events(b);
1044 b->last_connect_error = -r;
1047 r = bus_parse_next_address(b);
1051 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1055 int bus_next_address(sd_bus *b) {
1058 bus_reset_parsed_address(b);
1059 return bus_start_address(b);
1062 static int bus_start_fd(sd_bus *b) {
1067 assert(b->input_fd >= 0);
1068 assert(b->output_fd >= 0);
1070 r = fd_nonblock(b->input_fd, true);
1074 r = fd_cloexec(b->input_fd, true);
1078 if (b->input_fd != b->output_fd) {
1079 r = fd_nonblock(b->output_fd, true);
1083 r = fd_cloexec(b->output_fd, true);
1088 if (fstat(b->input_fd, &st) < 0)
1091 if (S_ISCHR(b->input_fd))
1092 return bus_kernel_take_fd(b);
1094 return bus_socket_take_fd(b);
1097 _public_ int sd_bus_start(sd_bus *bus) {
1100 assert_return(bus, -EINVAL);
1101 assert_return(bus->state == BUS_UNSET, -EPERM);
1102 assert_return(!bus_pid_changed(bus), -ECHILD);
1104 bus->state = BUS_OPENING;
1106 if (bus->is_server && bus->bus_client)
1109 if (bus->input_fd >= 0)
1110 r = bus_start_fd(bus);
1111 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1112 r = bus_start_address(bus);
1121 return bus_send_hello(bus);
1124 _public_ int sd_bus_open(sd_bus **ret) {
1129 assert_return(ret, -EINVAL);
1131 /* Let's connect to the starter bus if it is set, and
1132 * otherwise to the bus that is appropropriate for the scope
1133 * we are running in */
1135 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1137 if (streq(e, "system"))
1138 return sd_bus_open_system(ret);
1139 else if (STR_IN_SET(e, "session", "user"))
1140 return sd_bus_open_user(ret);
1143 e = secure_getenv("DBUS_STARTER_ADDRESS");
1145 return sd_bus_open_system(ret);
1152 r = sd_bus_set_address(b, e);
1156 b->bus_client = true;
1158 /* We don't know whether the bus is trusted or not, so better
1159 * be safe, and authenticate everything */
1161 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1162 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1164 r = sd_bus_start(b);
1176 int bus_set_address_system(sd_bus *b) {
1180 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1182 return sd_bus_set_address(b, e);
1184 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1187 _public_ int sd_bus_open_system(sd_bus **ret) {
1191 assert_return(ret, -EINVAL);
1197 r = bus_set_address_system(b);
1201 b->bus_client = true;
1202 b->is_system = true;
1204 /* Let's do per-method access control on the system bus. We
1205 * need the caller's UID and capability set for that. */
1207 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1208 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1210 r = sd_bus_start(b);
1222 int bus_set_address_user(sd_bus *b) {
1227 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1229 return sd_bus_set_address(b, e);
1231 e = secure_getenv("XDG_RUNTIME_DIR");
1233 _cleanup_free_ char *ee = NULL;
1235 ee = bus_address_escape(e);
1240 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1242 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1246 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1248 return -ECONNREFUSED;
1258 _public_ int sd_bus_open_user(sd_bus **ret) {
1262 assert_return(ret, -EINVAL);
1268 r = bus_set_address_user(b);
1272 b->bus_client = true;
1275 /* We don't do any per-method access control on the user
1279 r = sd_bus_start(b);
1291 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1292 _cleanup_free_ char *e = NULL;
1293 char *m = NULL, *c = NULL;
1298 /* Let's see if we shall enter some container */
1299 m = strchr(host, ':');
1303 /* Let's make sure this is not a port of some kind,
1304 * and is a valid machine name. */
1305 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1308 /* Cut out the host part */
1309 t = strndupa(host, m - host - 1);
1310 e = bus_address_escape(t);
1314 c = strjoina(",argv4=--machine=", m);
1319 e = bus_address_escape(host);
1324 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1331 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1335 assert_return(host, -EINVAL);
1336 assert_return(ret, -EINVAL);
1338 r = sd_bus_new(&bus);
1342 r = bus_set_address_system_remote(bus, host);
1346 bus->bus_client = true;
1347 bus->trusted = false;
1348 bus->is_system = true;
1350 r = sd_bus_start(bus);
1362 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1363 _cleanup_free_ char *e = NULL;
1368 e = bus_address_escape(machine);
1373 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1375 b->address = strjoin("x-machine-unix:machine=", e, NULL);
1383 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1387 assert_return(machine, -EINVAL);
1388 assert_return(ret, -EINVAL);
1389 assert_return(machine_name_is_valid(machine), -EINVAL);
1391 r = sd_bus_new(&bus);
1395 r = bus_set_address_system_machine(bus, machine);
1399 bus->bus_client = true;
1400 bus->trusted = false;
1401 bus->is_system = true;
1403 r = sd_bus_start(bus);
1415 _public_ void sd_bus_close(sd_bus *bus) {
1419 if (bus->state == BUS_CLOSED)
1421 if (bus_pid_changed(bus))
1424 bus->state = BUS_CLOSED;
1426 sd_bus_detach_event(bus);
1428 /* Drop all queued messages so that they drop references to
1429 * the bus object and the bus may be freed */
1430 bus_reset_queues(bus);
1432 if (!bus->is_kernel)
1435 /* We'll leave the fd open in case this is a kernel bus, since
1436 * there might still be memblocks around that reference this
1437 * bus, and they might need to invoke the KDBUS_CMD_FREE
1438 * ioctl on the fd when they are freed. */
1441 static void bus_enter_closing(sd_bus *bus) {
1444 if (bus->state != BUS_OPENING &&
1445 bus->state != BUS_AUTHENTICATING &&
1446 bus->state != BUS_HELLO &&
1447 bus->state != BUS_RUNNING)
1450 bus->state = BUS_CLOSING;
1453 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1454 assert_return(bus, NULL);
1456 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1461 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1467 i = REFCNT_DEC(bus->n_ref);
1475 _public_ int sd_bus_is_open(sd_bus *bus) {
1477 assert_return(bus, -EINVAL);
1478 assert_return(!bus_pid_changed(bus), -ECHILD);
1480 return BUS_IS_OPEN(bus->state);
1483 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1486 assert_return(bus, -EINVAL);
1487 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1488 assert_return(!bus_pid_changed(bus), -ECHILD);
1490 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1493 if (type == SD_BUS_TYPE_UNIX_FD) {
1494 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1497 r = bus_ensure_running(bus);
1501 return bus->can_fds;
1504 return bus_type_is_valid(type);
1507 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1510 assert_return(bus, -EINVAL);
1511 assert_return(id, -EINVAL);
1512 assert_return(!bus_pid_changed(bus), -ECHILD);
1514 r = bus_ensure_running(bus);
1518 *id = bus->server_id;
1522 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1527 /* If we copy the same message to multiple
1528 * destinations, avoid using the same cookie
1530 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1535 timeout = BUS_DEFAULT_TIMEOUT;
1537 return bus_message_seal(m, ++b->cookie, timeout);
1540 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1541 bool remarshal = false;
1545 /* wrong packet version */
1546 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1549 /* wrong packet endianness */
1550 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1553 /* TODO: kdbus-messages received from the kernel contain data which is
1554 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1555 * force remarshaling of the message. Technically, we could just
1556 * recreate the kdbus message, but that is non-trivial as other parts of
1557 * the message refer to m->kdbus already. This should be fixed! */
1558 if ((*m)->kdbus && (*m)->release_kdbus)
1561 return remarshal ? bus_message_remarshal(b, m) : 0;
1564 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1568 /* Fake some timestamps, if they were requested, and not
1569 * already initialized */
1570 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1571 if (m->realtime <= 0)
1572 m->realtime = now(CLOCK_REALTIME);
1574 if (m->monotonic <= 0)
1575 m->monotonic = now(CLOCK_MONOTONIC);
1578 /* The bus specification says the serial number cannot be 0,
1579 * hence let's fill something in for synthetic messages. Since
1580 * synthetic messages might have a fake sender and we don't
1581 * want to interfere with the real sender's serial numbers we
1582 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1583 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1584 * even though kdbus can do 64bit. */
1585 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1588 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1595 r = bus_kernel_write_message(bus, m, hint_sync_call);
1597 r = bus_socket_write_message(bus, m, idx);
1602 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1603 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1604 bus_message_type_to_string(m->header->type),
1605 strna(sd_bus_message_get_sender(m)),
1606 strna(sd_bus_message_get_destination(m)),
1607 strna(sd_bus_message_get_path(m)),
1608 strna(sd_bus_message_get_interface(m)),
1609 strna(sd_bus_message_get_member(m)),
1610 BUS_MESSAGE_COOKIE(m),
1612 strna(m->error.message));
1617 static int dispatch_wqueue(sd_bus *bus) {
1621 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1623 while (bus->wqueue_size > 0) {
1625 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1629 /* Didn't do anything this time */
1631 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1632 /* Fully written. Let's drop the entry from
1635 * This isn't particularly optimized, but
1636 * well, this is supposed to be our worst-case
1637 * buffer only, and the socket buffer is
1638 * supposed to be our primary buffer, and if
1639 * it got full, then all bets are off
1642 bus->wqueue_size --;
1643 sd_bus_message_unref(bus->wqueue[0]);
1644 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1654 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1658 return bus_kernel_read_message(bus, hint_priority, priority);
1660 return bus_socket_read_message(bus);
1663 int bus_rqueue_make_room(sd_bus *bus) {
1666 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1669 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1675 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1680 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1682 /* Note that the priority logic is only available on kdbus,
1683 * where the rqueue is unused. We check the rqueue here
1684 * anyway, because it's simple... */
1687 if (bus->rqueue_size > 0) {
1688 /* Dispatch a queued message */
1690 *m = bus->rqueue[0];
1691 bus->rqueue_size --;
1692 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1696 /* Try to read a new message */
1697 r = bus_read_message(bus, hint_priority, priority);
1707 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1708 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1711 assert_return(m, -EINVAL);
1716 assert_return(!bus_pid_changed(bus), -ECHILD);
1717 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1719 if (!BUS_IS_OPEN(bus->state))
1723 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1730 /* If the cookie number isn't kept, then we know that no reply
1732 if (!cookie && !m->sealed)
1733 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1735 r = bus_seal_message(bus, m, 0);
1739 /* Remarshall if we have to. This will possibly unref the
1740 * message and place a replacement in m */
1741 r = bus_remarshal_message(bus, &m);
1745 /* If this is a reply and no reply was requested, then let's
1746 * suppress this, if we can */
1750 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1753 r = bus_write_message(bus, m, hint_sync_call, &idx);
1755 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1756 bus_enter_closing(bus);
1763 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1764 /* Wasn't fully written. So let's remember how
1765 * much was written. Note that the first entry
1766 * of the wqueue array is always allocated so
1767 * that we always can remember how much was
1769 bus->wqueue[0] = sd_bus_message_ref(m);
1770 bus->wqueue_size = 1;
1775 /* Just append it to the queue. */
1777 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1780 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1783 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1788 *cookie = BUS_MESSAGE_COOKIE(m);
1793 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1794 return bus_send_internal(bus, m, cookie, false);
1797 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1800 assert_return(m, -EINVAL);
1805 assert_return(!bus_pid_changed(bus), -ECHILD);
1807 if (!BUS_IS_OPEN(bus->state))
1810 if (!streq_ptr(m->destination, destination)) {
1815 r = sd_bus_message_set_destination(m, destination);
1820 return sd_bus_send(bus, m, cookie);
1823 static usec_t calc_elapse(uint64_t usec) {
1824 if (usec == (uint64_t) -1)
1827 return now(CLOCK_MONOTONIC) + usec;
1830 static int timeout_compare(const void *a, const void *b) {
1831 const struct reply_callback *x = a, *y = b;
1833 if (x->timeout != 0 && y->timeout == 0)
1836 if (x->timeout == 0 && y->timeout != 0)
1839 if (x->timeout < y->timeout)
1842 if (x->timeout > y->timeout)
1848 _public_ int sd_bus_call_async(
1852 sd_bus_message_handler_t callback,
1856 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1857 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1860 assert_return(m, -EINVAL);
1861 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1862 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1863 assert_return(callback, -EINVAL);
1868 assert_return(!bus_pid_changed(bus), -ECHILD);
1869 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1871 if (!BUS_IS_OPEN(bus->state))
1874 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1878 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1882 r = bus_seal_message(bus, m, usec);
1886 r = bus_remarshal_message(bus, &m);
1890 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1894 s->reply_callback.callback = callback;
1896 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1897 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1899 s->reply_callback.cookie = 0;
1903 s->reply_callback.timeout = calc_elapse(m->timeout);
1904 if (s->reply_callback.timeout != 0) {
1905 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1907 s->reply_callback.timeout = 0;
1912 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1923 int bus_ensure_running(sd_bus *bus) {
1928 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1930 if (bus->state == BUS_RUNNING)
1934 r = sd_bus_process(bus, NULL);
1937 if (bus->state == BUS_RUNNING)
1942 r = sd_bus_wait(bus, (uint64_t) -1);
1948 _public_ int sd_bus_call(
1952 sd_bus_error *error,
1953 sd_bus_message **reply) {
1955 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1961 assert_return(m, -EINVAL);
1962 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1963 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1964 assert_return(!bus_error_is_dirty(error), -EINVAL);
1969 assert_return(!bus_pid_changed(bus), -ECHILD);
1970 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1972 if (!BUS_IS_OPEN(bus->state))
1975 r = bus_ensure_running(bus);
1979 i = bus->rqueue_size;
1981 r = bus_seal_message(bus, m, usec);
1985 r = bus_remarshal_message(bus, &m);
1989 r = bus_send_internal(bus, m, &cookie, true);
1993 timeout = calc_elapse(m->timeout);
1998 while (i < bus->rqueue_size) {
1999 sd_bus_message *incoming = NULL;
2001 incoming = bus->rqueue[i];
2003 if (incoming->reply_cookie == cookie) {
2004 /* Found a match! */
2006 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2008 log_debug_bus_message(incoming);
2010 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2012 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2016 sd_bus_message_unref(incoming);
2021 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2023 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
2024 r = sd_bus_error_copy(error, &incoming->error);
2028 sd_bus_message_unref(incoming);
2031 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2034 streq(bus->unique_name, incoming->sender)) {
2036 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2039 /* Our own message? Somebody is trying
2040 * to send its own client a message,
2041 * let's not dead-lock, let's fail
2044 sd_bus_message_unref(incoming);
2048 /* Try to read more, right-away */
2052 r = bus_read_message(bus, false, 0);
2054 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2055 bus_enter_closing(bus);
2067 n = now(CLOCK_MONOTONIC);
2073 left = (uint64_t) -1;
2075 r = bus_poll(bus, true, left);
2081 r = dispatch_wqueue(bus);
2083 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2084 bus_enter_closing(bus);
2093 _public_ int sd_bus_get_fd(sd_bus *bus) {
2095 assert_return(bus, -EINVAL);
2096 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2097 assert_return(!bus_pid_changed(bus), -ECHILD);
2099 return bus->input_fd;
2102 _public_ int sd_bus_get_events(sd_bus *bus) {
2105 assert_return(bus, -EINVAL);
2106 assert_return(!bus_pid_changed(bus), -ECHILD);
2108 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2111 if (bus->state == BUS_OPENING)
2113 else if (bus->state == BUS_AUTHENTICATING) {
2115 if (bus_socket_auth_needs_write(bus))
2120 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2121 if (bus->rqueue_size <= 0)
2123 if (bus->wqueue_size > 0)
2130 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2131 struct reply_callback *c;
2133 assert_return(bus, -EINVAL);
2134 assert_return(timeout_usec, -EINVAL);
2135 assert_return(!bus_pid_changed(bus), -ECHILD);
2137 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2140 if (bus->track_queue) {
2145 if (bus->state == BUS_CLOSING) {
2150 if (bus->state == BUS_AUTHENTICATING) {
2151 *timeout_usec = bus->auth_timeout;
2155 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2156 *timeout_usec = (uint64_t) -1;
2160 if (bus->rqueue_size > 0) {
2165 c = prioq_peek(bus->reply_callbacks_prioq);
2167 *timeout_usec = (uint64_t) -1;
2171 if (c->timeout == 0) {
2172 *timeout_usec = (uint64_t) -1;
2176 *timeout_usec = c->timeout;
2180 static int process_timeout(sd_bus *bus) {
2181 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2182 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2183 struct reply_callback *c;
2190 c = prioq_peek(bus->reply_callbacks_prioq);
2194 n = now(CLOCK_MONOTONIC);
2198 r = bus_message_new_synthetic_error(
2201 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2206 r = bus_seal_synthetic_message(bus, m);
2210 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2213 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2216 slot = container_of(c, sd_bus_slot, reply_callback);
2218 bus->iteration_counter ++;
2220 bus->current_message = m;
2221 bus->current_slot = sd_bus_slot_ref(slot);
2222 bus->current_handler = c->callback;
2223 bus->current_userdata = slot->userdata;
2224 r = c->callback(m, slot->userdata, &error_buffer);
2225 bus->current_userdata = NULL;
2226 bus->current_handler = NULL;
2227 bus->current_slot = NULL;
2228 bus->current_message = NULL;
2230 if (slot->floating) {
2231 bus_slot_disconnect(slot);
2232 sd_bus_slot_unref(slot);
2235 sd_bus_slot_unref(slot);
2237 return bus_maybe_reply_error(m, r, &error_buffer);
2240 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2244 if (bus->state != BUS_HELLO)
2247 /* Let's make sure the first message on the bus is the HELLO
2248 * reply. But note that we don't actually parse the message
2249 * here (we leave that to the usual handling), we just verify
2250 * we don't let any earlier msg through. */
2252 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2253 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2256 if (m->reply_cookie != 1)
2262 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2263 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2264 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2265 struct reply_callback *c;
2272 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2273 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2276 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2279 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2282 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2288 slot = container_of(c, sd_bus_slot, reply_callback);
2290 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2292 /* If the reply contained a file descriptor which we
2293 * didn't want we pass an error instead. */
2295 r = bus_message_new_synthetic_error(
2298 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2303 /* Copy over original timestamp */
2304 synthetic_reply->realtime = m->realtime;
2305 synthetic_reply->monotonic = m->monotonic;
2306 synthetic_reply->seqnum = m->seqnum;
2308 r = bus_seal_synthetic_message(bus, synthetic_reply);
2312 m = synthetic_reply;
2314 r = sd_bus_message_rewind(m, true);
2319 if (c->timeout != 0) {
2320 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2324 bus->current_slot = sd_bus_slot_ref(slot);
2325 bus->current_handler = c->callback;
2326 bus->current_userdata = slot->userdata;
2327 r = c->callback(m, slot->userdata, &error_buffer);
2328 bus->current_userdata = NULL;
2329 bus->current_handler = NULL;
2330 bus->current_slot = NULL;
2332 if (slot->floating) {
2333 bus_slot_disconnect(slot);
2334 sd_bus_slot_unref(slot);
2337 sd_bus_slot_unref(slot);
2339 return bus_maybe_reply_error(m, r, &error_buffer);
2342 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2343 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2344 struct filter_callback *l;
2351 bus->filter_callbacks_modified = false;
2353 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2356 if (bus->filter_callbacks_modified)
2359 /* Don't run this more than once per iteration */
2360 if (l->last_iteration == bus->iteration_counter)
2363 l->last_iteration = bus->iteration_counter;
2365 r = sd_bus_message_rewind(m, true);
2369 slot = container_of(l, sd_bus_slot, filter_callback);
2371 bus->current_slot = sd_bus_slot_ref(slot);
2372 bus->current_handler = l->callback;
2373 bus->current_userdata = slot->userdata;
2374 r = l->callback(m, slot->userdata, &error_buffer);
2375 bus->current_userdata = NULL;
2376 bus->current_handler = NULL;
2377 bus->current_slot = sd_bus_slot_unref(slot);
2379 r = bus_maybe_reply_error(m, r, &error_buffer);
2385 } while (bus->filter_callbacks_modified);
2390 static int process_match(sd_bus *bus, sd_bus_message *m) {
2397 bus->match_callbacks_modified = false;
2399 r = bus_match_run(bus, &bus->match_callbacks, m);
2403 } while (bus->match_callbacks_modified);
2408 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2409 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2415 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2418 if (bus->manual_peer_interface)
2421 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2424 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2427 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2430 if (streq_ptr(m->member, "Ping"))
2431 r = sd_bus_message_new_method_return(m, &reply);
2432 else if (streq_ptr(m->member, "GetMachineId")) {
2436 r = sd_id128_get_machine(&id);
2440 r = sd_bus_message_new_method_return(m, &reply);
2444 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2446 r = sd_bus_message_new_method_errorf(
2448 SD_BUS_ERROR_UNKNOWN_METHOD,
2449 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2455 r = sd_bus_send(bus, reply, NULL);
2462 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2466 /* If we got a message with a file descriptor which we didn't
2467 * want to accept, then let's drop it. How can this even
2468 * happen? For example, when the kernel queues a message into
2469 * an activatable names's queue which allows fds, and then is
2470 * delivered to us later even though we ourselves did not
2473 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2479 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2482 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2483 return 1; /* just eat it up */
2485 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2488 static int process_message(sd_bus *bus, sd_bus_message *m) {
2494 bus->current_message = m;
2495 bus->iteration_counter++;
2497 log_debug_bus_message(m);
2499 r = process_hello(bus, m);
2503 r = process_reply(bus, m);
2507 r = process_fd_check(bus, m);
2511 r = process_filter(bus, m);
2515 r = process_match(bus, m);
2519 r = process_builtin(bus, m);
2523 r = bus_process_object(bus, m);
2526 bus->current_message = NULL;
2530 static int dispatch_track(sd_bus *bus) {
2533 if (!bus->track_queue)
2536 bus_track_dispatch(bus->track_queue);
2540 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2541 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2545 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2547 r = process_timeout(bus);
2551 r = dispatch_wqueue(bus);
2555 r = dispatch_track(bus);
2559 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2565 r = process_message(bus, m);
2570 r = sd_bus_message_rewind(m, true);
2579 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2581 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2582 strna(sd_bus_message_get_sender(m)),
2583 strna(sd_bus_message_get_path(m)),
2584 strna(sd_bus_message_get_interface(m)),
2585 strna(sd_bus_message_get_member(m)));
2587 r = sd_bus_reply_method_errorf(
2589 SD_BUS_ERROR_UNKNOWN_OBJECT,
2590 "Unknown object '%s'.", m->path);
2604 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2605 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2606 struct reply_callback *c;
2610 assert(bus->state == BUS_CLOSING);
2612 c = ordered_hashmap_first(bus->reply_callbacks);
2614 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2617 /* First, fail all outstanding method calls */
2618 r = bus_message_new_synthetic_error(
2621 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2626 r = bus_seal_synthetic_message(bus, m);
2630 if (c->timeout != 0) {
2631 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2635 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2638 slot = container_of(c, sd_bus_slot, reply_callback);
2640 bus->iteration_counter++;
2642 bus->current_message = m;
2643 bus->current_slot = sd_bus_slot_ref(slot);
2644 bus->current_handler = c->callback;
2645 bus->current_userdata = slot->userdata;
2646 r = c->callback(m, slot->userdata, &error_buffer);
2647 bus->current_userdata = NULL;
2648 bus->current_handler = NULL;
2649 bus->current_slot = NULL;
2650 bus->current_message = NULL;
2652 if (slot->floating) {
2653 bus_slot_disconnect(slot);
2654 sd_bus_slot_unref(slot);
2657 sd_bus_slot_unref(slot);
2659 return bus_maybe_reply_error(m, r, &error_buffer);
2662 /* Then, synthesize a Disconnected message */
2663 r = sd_bus_message_new_signal(
2666 "/org/freedesktop/DBus/Local",
2667 "org.freedesktop.DBus.Local",
2672 bus_message_set_sender_local(bus, m);
2674 r = bus_seal_synthetic_message(bus, m);
2680 bus->current_message = m;
2681 bus->iteration_counter++;
2683 r = process_filter(bus, m);
2687 r = process_match(bus, m);
2699 bus->current_message = NULL;
2704 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2705 BUS_DONT_DESTROY(bus);
2708 /* Returns 0 when we didn't do anything. This should cause the
2709 * caller to invoke sd_bus_wait() before returning the next
2710 * time. Returns > 0 when we did something, which possibly
2711 * means *ret is filled in with an unprocessed message. */
2713 assert_return(bus, -EINVAL);
2714 assert_return(!bus_pid_changed(bus), -ECHILD);
2716 /* We don't allow recursively invoking sd_bus_process(). */
2717 assert_return(!bus->current_message, -EBUSY);
2718 assert(!bus->current_slot);
2720 switch (bus->state) {
2729 r = bus_socket_process_opening(bus);
2730 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2731 bus_enter_closing(bus);
2739 case BUS_AUTHENTICATING:
2740 r = bus_socket_process_authenticating(bus);
2741 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2742 bus_enter_closing(bus);
2754 r = process_running(bus, hint_priority, priority, ret);
2755 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2756 bus_enter_closing(bus);
2766 return process_closing(bus, ret);
2769 assert_not_reached("Unknown state");
2772 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2773 return bus_process_internal(bus, false, 0, ret);
2776 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2777 return bus_process_internal(bus, true, priority, ret);
2780 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2781 struct pollfd p[2] = {};
2784 usec_t m = USEC_INFINITY;
2788 if (bus->state == BUS_CLOSING)
2791 if (!BUS_IS_OPEN(bus->state))
2794 e = sd_bus_get_events(bus);
2799 /* The caller really needs some more data, he doesn't
2800 * care about what's already read, or any timeouts
2801 * except its own. */
2805 /* The caller wants to process if there's something to
2806 * process, but doesn't care otherwise */
2808 r = sd_bus_get_timeout(bus, &until);
2813 nw = now(CLOCK_MONOTONIC);
2814 m = until > nw ? until - nw : 0;
2818 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2821 p[0].fd = bus->input_fd;
2822 if (bus->output_fd == bus->input_fd) {
2826 p[0].events = e & POLLIN;
2827 p[1].fd = bus->output_fd;
2828 p[1].events = e & POLLOUT;
2832 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2836 return r > 0 ? 1 : 0;
2839 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2841 assert_return(bus, -EINVAL);
2842 assert_return(!bus_pid_changed(bus), -ECHILD);
2844 if (bus->state == BUS_CLOSING)
2847 if (!BUS_IS_OPEN(bus->state))
2850 if (bus->rqueue_size > 0)
2853 return bus_poll(bus, false, timeout_usec);
2856 _public_ int sd_bus_flush(sd_bus *bus) {
2859 assert_return(bus, -EINVAL);
2860 assert_return(!bus_pid_changed(bus), -ECHILD);
2862 if (bus->state == BUS_CLOSING)
2865 if (!BUS_IS_OPEN(bus->state))
2868 r = bus_ensure_running(bus);
2872 if (bus->wqueue_size <= 0)
2876 r = dispatch_wqueue(bus);
2878 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2879 bus_enter_closing(bus);
2886 if (bus->wqueue_size <= 0)
2889 r = bus_poll(bus, false, (uint64_t) -1);
2895 _public_ int sd_bus_add_filter(
2898 sd_bus_message_handler_t callback,
2903 assert_return(bus, -EINVAL);
2904 assert_return(callback, -EINVAL);
2905 assert_return(!bus_pid_changed(bus), -ECHILD);
2907 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2911 s->filter_callback.callback = callback;
2913 bus->filter_callbacks_modified = true;
2914 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2922 _public_ int sd_bus_add_match(
2926 sd_bus_message_handler_t callback,
2929 struct bus_match_component *components = NULL;
2930 unsigned n_components = 0;
2931 sd_bus_slot *s = NULL;
2934 assert_return(bus, -EINVAL);
2935 assert_return(match, -EINVAL);
2936 assert_return(!bus_pid_changed(bus), -ECHILD);
2938 r = bus_match_parse(match, &components, &n_components);
2942 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2948 s->match_callback.callback = callback;
2949 s->match_callback.cookie = ++bus->match_cookie;
2951 if (bus->bus_client) {
2953 if (!bus->is_kernel) {
2954 /* When this is not a kernel transport, we
2955 * store the original match string, so that we
2956 * can use it to remove the match again */
2958 s->match_callback.match_string = strdup(match);
2959 if (!s->match_callback.match_string) {
2965 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2970 bus->match_callbacks_modified = true;
2971 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2980 bus_match_parse_free(components, n_components);
2981 sd_bus_slot_unref(s);
2986 int bus_remove_match_by_string(
2989 sd_bus_message_handler_t callback,
2992 struct bus_match_component *components = NULL;
2993 unsigned n_components = 0;
2994 struct match_callback *c;
2997 assert_return(bus, -EINVAL);
2998 assert_return(match, -EINVAL);
2999 assert_return(!bus_pid_changed(bus), -ECHILD);
3001 r = bus_match_parse(match, &components, &n_components);
3005 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3009 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3012 bus_match_parse_free(components, n_components);
3017 bool bus_pid_changed(sd_bus *bus) {
3020 /* We don't support people creating a bus connection and
3021 * keeping it around over a fork(). Let's complain. */
3023 return bus->original_pid != getpid();
3026 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3027 sd_bus *bus = userdata;
3032 r = sd_bus_process(bus, NULL);
3039 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3040 sd_bus *bus = userdata;
3045 r = sd_bus_process(bus, NULL);
3052 static int prepare_callback(sd_event_source *s, void *userdata) {
3053 sd_bus *bus = userdata;
3060 e = sd_bus_get_events(bus);
3064 if (bus->output_fd != bus->input_fd) {
3066 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3070 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3074 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3079 r = sd_bus_get_timeout(bus, &until);
3085 j = sd_event_source_set_time(bus->time_event_source, until);
3090 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3097 static int quit_callback(sd_event_source *event, void *userdata) {
3098 sd_bus *bus = userdata;
3108 static int attach_io_events(sd_bus *bus) {
3113 if (bus->input_fd < 0)
3119 if (!bus->input_io_event_source) {
3120 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3124 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3128 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3132 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3134 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3139 if (bus->output_fd != bus->input_fd) {
3140 assert(bus->output_fd >= 0);
3142 if (!bus->output_io_event_source) {
3143 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3147 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3151 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3153 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3162 static void detach_io_events(sd_bus *bus) {
3165 if (bus->input_io_event_source) {
3166 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3167 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3170 if (bus->output_io_event_source) {
3171 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3172 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3176 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3179 assert_return(bus, -EINVAL);
3180 assert_return(!bus->event, -EBUSY);
3182 assert(!bus->input_io_event_source);
3183 assert(!bus->output_io_event_source);
3184 assert(!bus->time_event_source);
3187 bus->event = sd_event_ref(event);
3189 r = sd_event_default(&bus->event);
3194 bus->event_priority = priority;
3196 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3200 r = sd_event_source_set_priority(bus->time_event_source, priority);
3204 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3208 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3212 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3216 r = attach_io_events(bus);
3223 sd_bus_detach_event(bus);
3227 _public_ int sd_bus_detach_event(sd_bus *bus) {
3228 assert_return(bus, -EINVAL);
3233 detach_io_events(bus);
3235 if (bus->time_event_source) {
3236 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3237 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3240 if (bus->quit_event_source) {
3241 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3242 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3245 bus->event = sd_event_unref(bus->event);
3249 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3250 assert_return(bus, NULL);
3255 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3256 assert_return(bus, NULL);
3258 return bus->current_message;
3261 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3262 assert_return(bus, NULL);
3264 return bus->current_slot;
3267 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3268 assert_return(bus, NULL);
3270 return bus->current_handler;
3273 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3274 assert_return(bus, NULL);
3276 return bus->current_userdata;
3279 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3284 assert(default_bus);
3287 return !!*default_bus;
3290 *ret = sd_bus_ref(*default_bus);
3298 b->default_bus_ptr = default_bus;
3306 _public_ int sd_bus_default_system(sd_bus **ret) {
3307 static thread_local sd_bus *default_system_bus = NULL;
3309 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3312 _public_ int sd_bus_default_user(sd_bus **ret) {
3313 static thread_local sd_bus *default_user_bus = NULL;
3315 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3318 _public_ int sd_bus_default(sd_bus **ret) {
3322 /* Let's try our best to reuse another cached connection. If
3323 * the starter bus type is set, connect via our normal
3324 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3325 * we can share the connection with the user/system default
3328 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3330 if (streq(e, "system"))
3331 return sd_bus_default_system(ret);
3332 else if (STR_IN_SET(e, "user", "session"))
3333 return sd_bus_default_user(ret);
3336 /* No type is specified, so we have not other option than to
3337 * use the starter address if it is set. */
3339 e = secure_getenv("DBUS_STARTER_ADDRESS");
3341 static thread_local sd_bus *default_starter_bus = NULL;
3343 return bus_default(sd_bus_open, &default_starter_bus, ret);
3346 /* Finally, if nothing is set use the cached connection for
3347 * the right scope */
3349 return sd_bus_default_system(ret);
3352 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3353 assert_return(b, -EINVAL);
3354 assert_return(tid, -EINVAL);
3355 assert_return(!bus_pid_changed(b), -ECHILD);
3363 return sd_event_get_tid(b->event, tid);
3368 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3369 _cleanup_free_ char *e = NULL;
3372 assert_return(object_path_is_valid(prefix), -EINVAL);
3373 assert_return(external_id, -EINVAL);
3374 assert_return(ret_path, -EINVAL);
3376 e = bus_label_escape(external_id);
3380 ret = strjoin(prefix, "/", e, NULL);
3388 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3392 assert_return(object_path_is_valid(path), -EINVAL);
3393 assert_return(object_path_is_valid(prefix), -EINVAL);
3394 assert_return(external_id, -EINVAL);
3396 e = object_path_startswith(path, prefix);
3398 *external_id = NULL;
3402 ret = bus_label_unescape(e);
3410 _public_ int sd_bus_try_close(sd_bus *bus) {
3413 assert_return(bus, -EINVAL);
3414 assert_return(!bus_pid_changed(bus), -ECHILD);
3416 if (!bus->is_kernel)
3419 if (!BUS_IS_OPEN(bus->state))
3422 if (bus->rqueue_size > 0)
3425 if (bus->wqueue_size > 0)
3428 r = bus_kernel_try_close(bus);
3436 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3437 assert_return(bus, -EINVAL);
3438 assert_return(description, -EINVAL);
3439 assert_return(bus->description, -ENXIO);
3440 assert_return(!bus_pid_changed(bus), -ECHILD);
3442 *description = bus->description;
3446 int bus_get_root_path(sd_bus *bus) {
3449 if (bus->cgroup_root)
3452 r = cg_get_root_path(&bus->cgroup_root);
3454 bus->cgroup_root = strdup("/");
3455 if (!bus->cgroup_root)
3464 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3467 assert_return(bus, -EINVAL);
3468 assert_return(scope, -EINVAL);
3469 assert_return(!bus_pid_changed(bus), -ECHILD);
3471 if (bus->is_kernel) {
3472 _cleanup_free_ char *n = NULL;
3475 r = bus_kernel_get_bus_name(bus, &n);
3479 if (streq(n, "0-system")) {
3484 dash = strchr(n, '-');
3485 if (streq_ptr(dash, "-user")) {
3496 if (bus->is_system) {
3504 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3506 assert_return(bus, -EINVAL);
3507 assert_return(address, -EINVAL);
3508 assert_return(!bus_pid_changed(bus), -ECHILD);
3511 *address = bus->address;
3518 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3519 assert_return(bus, -EINVAL);
3520 assert_return(mask, -EINVAL);
3521 assert_return(!bus_pid_changed(bus), -ECHILD);
3523 *mask = bus->creds_mask;
3527 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3528 assert_return(bus, -EINVAL);
3529 assert_return(!bus_pid_changed(bus), -ECHILD);
3531 return bus->bus_client;
3534 _public_ int sd_bus_is_server(sd_bus *bus) {
3535 assert_return(bus, -EINVAL);
3536 assert_return(!bus_pid_changed(bus), -ECHILD);
3538 return bus->is_server;
3541 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3542 assert_return(bus, -EINVAL);
3543 assert_return(!bus_pid_changed(bus), -ECHILD);
3545 return bus->anonymous_auth;
3548 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3549 assert_return(bus, -EINVAL);
3550 assert_return(!bus_pid_changed(bus), -ECHILD);
3552 return bus->trusted;
3555 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3556 assert_return(bus, -EINVAL);
3557 assert_return(!bus_pid_changed(bus), -ECHILD);
3559 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);