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) do { \
53 sd_bus_message *_m = (m); \
54 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
55 bus_message_type_to_string(_m->header->type), \
56 strna(sd_bus_message_get_sender(_m)), \
57 strna(sd_bus_message_get_destination(_m)), \
58 strna(sd_bus_message_get_path(_m)), \
59 strna(sd_bus_message_get_interface(_m)), \
60 strna(sd_bus_message_get_member(_m)), \
61 BUS_MESSAGE_COOKIE(_m), \
63 strna(_m->error.message)); \
66 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
67 static int attach_io_events(sd_bus *b);
68 static void detach_io_events(sd_bus *b);
70 static void bus_close_fds(sd_bus *b) {
76 safe_close(b->input_fd);
78 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
79 safe_close(b->output_fd);
81 b->input_fd = b->output_fd = -1;
84 static void bus_reset_queues(sd_bus *b) {
87 while (b->rqueue_size > 0)
88 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
92 b->rqueue_allocated = 0;
94 while (b->wqueue_size > 0)
95 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
99 b->wqueue_allocated = 0;
102 static void bus_free(sd_bus *b) {
106 assert(!b->track_queue);
108 b->state = BUS_CLOSED;
110 sd_bus_detach_event(b);
112 while ((s = b->slots)) {
113 /* At this point only floating slots can still be
114 * around, because the non-floating ones keep a
115 * reference to the bus, and we thus couldn't be
116 * destructing right now... We forcibly disconnect the
117 * slots here, so that they still can be referenced by
118 * apps, but are dead. */
121 bus_slot_disconnect(s);
122 sd_bus_slot_unref(s);
125 if (b->default_bus_ptr)
126 *b->default_bus_ptr = NULL;
131 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
135 free(b->unique_name);
136 free(b->auth_buffer);
141 free(b->cgroup_root);
142 free(b->description);
145 strv_free(b->exec_argv);
147 close_many(b->fds, b->n_fds);
152 ordered_hashmap_free_free(b->reply_callbacks);
153 prioq_free(b->reply_callbacks_prioq);
155 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
156 bus_match_free(&b->match_callbacks);
158 hashmap_free_free(b->vtable_methods);
159 hashmap_free_free(b->vtable_properties);
161 assert(hashmap_isempty(b->nodes));
162 hashmap_free(b->nodes);
164 bus_kernel_flush_memfd(b);
166 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
171 _public_ int sd_bus_new(sd_bus **ret) {
174 assert_return(ret, -EINVAL);
180 r->n_ref = REFCNT_INIT;
181 r->input_fd = r->output_fd = -1;
182 r->message_version = 1;
183 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
184 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
185 r->attach_flags |= KDBUS_ATTACH_NAMES;
186 r->original_pid = getpid();
188 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
190 /* We guarantee that wqueue always has space for at least one
192 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
201 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
204 assert_return(bus, -EINVAL);
205 assert_return(bus->state == BUS_UNSET, -EPERM);
206 assert_return(address, -EINVAL);
207 assert_return(!bus_pid_changed(bus), -ECHILD);
219 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
220 assert_return(bus, -EINVAL);
221 assert_return(bus->state == BUS_UNSET, -EPERM);
222 assert_return(input_fd >= 0, -EINVAL);
223 assert_return(output_fd >= 0, -EINVAL);
224 assert_return(!bus_pid_changed(bus), -ECHILD);
226 bus->input_fd = input_fd;
227 bus->output_fd = output_fd;
231 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
234 assert_return(bus, -EINVAL);
235 assert_return(bus->state == BUS_UNSET, -EPERM);
236 assert_return(path, -EINVAL);
237 assert_return(!strv_isempty(argv), -EINVAL);
238 assert_return(!bus_pid_changed(bus), -ECHILD);
250 free(bus->exec_path);
251 strv_free(bus->exec_argv);
259 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
260 assert_return(bus, -EINVAL);
261 assert_return(bus->state == BUS_UNSET, -EPERM);
262 assert_return(!bus_pid_changed(bus), -ECHILD);
264 bus->bus_client = !!b;
268 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
269 assert_return(bus, -EINVAL);
270 assert_return(bus->state == BUS_UNSET, -EPERM);
271 assert_return(!bus_pid_changed(bus), -ECHILD);
273 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
277 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
278 assert_return(bus, -EINVAL);
279 assert_return(bus->state == BUS_UNSET, -EPERM);
280 assert_return(!bus_pid_changed(bus), -ECHILD);
282 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
286 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
288 assert_return(bus, -EINVAL);
289 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
290 assert_return(!bus_pid_changed(bus), -ECHILD);
292 new_flags = bus->attach_flags;
293 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
295 if (bus->attach_flags == new_flags)
298 bus->attach_flags = new_flags;
299 if (bus->state != BUS_UNSET && bus->is_kernel)
300 bus_kernel_realize_attach_flags(bus);
305 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
308 assert_return(bus, -EINVAL);
309 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
310 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
311 assert_return(!bus_pid_changed(bus), -ECHILD);
314 bus->creds_mask |= mask;
316 bus->creds_mask &= ~mask;
318 /* The well knowns we need unconditionally, so that matches can work */
319 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
321 /* Make sure we don't lose the timestamp flag */
322 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
323 if (bus->attach_flags == new_flags)
326 bus->attach_flags = new_flags;
327 if (bus->state != BUS_UNSET && bus->is_kernel)
328 bus_kernel_realize_attach_flags(bus);
333 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
334 assert_return(bus, -EINVAL);
335 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
336 assert_return(bus->state == BUS_UNSET, -EPERM);
337 assert_return(!bus_pid_changed(bus), -ECHILD);
339 bus->is_server = !!b;
340 bus->server_id = server_id;
344 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
345 assert_return(bus, -EINVAL);
346 assert_return(bus->state == BUS_UNSET, -EPERM);
347 assert_return(!bus_pid_changed(bus), -ECHILD);
349 bus->anonymous_auth = !!b;
353 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
354 assert_return(bus, -EINVAL);
355 assert_return(bus->state == BUS_UNSET, -EPERM);
356 assert_return(!bus_pid_changed(bus), -ECHILD);
362 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
363 assert_return(bus, -EINVAL);
364 assert_return(bus->state == BUS_UNSET, -EPERM);
365 assert_return(!bus_pid_changed(bus), -ECHILD);
367 return free_and_strdup(&bus->description, description);
370 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
371 assert_return(bus, -EINVAL);
372 assert_return(!bus_pid_changed(bus), -ECHILD);
374 bus->allow_interactive_authorization = !!b;
378 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
379 assert_return(bus, -EINVAL);
380 assert_return(!bus_pid_changed(bus), -ECHILD);
382 return bus->allow_interactive_authorization;
385 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
393 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
395 r = sd_bus_message_get_errno(reply);
399 r = sd_bus_message_read(reply, "s", &s);
403 if (!service_name_is_valid(s) || s[0] != ':')
406 bus->unique_name = strdup(s);
407 if (!bus->unique_name)
410 if (bus->state == BUS_HELLO)
411 bus->state = BUS_RUNNING;
416 static int bus_send_hello(sd_bus *bus) {
417 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
422 if (!bus->bus_client || bus->is_kernel)
425 r = sd_bus_message_new_method_call(
428 "org.freedesktop.DBus",
429 "/org/freedesktop/DBus",
430 "org.freedesktop.DBus",
435 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
438 int bus_start_running(sd_bus *bus) {
441 if (bus->bus_client && !bus->is_kernel) {
442 bus->state = BUS_HELLO;
446 bus->state = BUS_RUNNING;
450 static int parse_address_key(const char **p, const char *key, char **value) {
451 size_t l, n = 0, allocated = 0;
461 if (strncmp(*p, key, l) != 0)
474 while (*a != ';' && *a != ',' && *a != 0) {
492 c = (char) ((x << 4) | y);
499 if (!GREEDY_REALLOC(r, allocated, n + 2))
523 static void skip_address_key(const char **p) {
527 *p += strcspn(*p, ",");
533 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
534 _cleanup_free_ char *path = NULL, *abstract = NULL;
543 while (**p != 0 && **p != ';') {
544 r = parse_address_key(p, "guid", guid);
550 r = parse_address_key(p, "path", &path);
556 r = parse_address_key(p, "abstract", &abstract);
565 if (!path && !abstract)
568 if (path && abstract)
573 if (l > sizeof(b->sockaddr.un.sun_path))
576 b->sockaddr.un.sun_family = AF_UNIX;
577 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
578 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
579 } else if (abstract) {
580 l = strlen(abstract);
581 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
584 b->sockaddr.un.sun_family = AF_UNIX;
585 b->sockaddr.un.sun_path[0] = 0;
586 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
587 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
593 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
594 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
596 struct addrinfo *result, hints = {
597 .ai_socktype = SOCK_STREAM,
598 .ai_flags = AI_ADDRCONFIG,
606 while (**p != 0 && **p != ';') {
607 r = parse_address_key(p, "guid", guid);
613 r = parse_address_key(p, "host", &host);
619 r = parse_address_key(p, "port", &port);
625 r = parse_address_key(p, "family", &family);
638 if (streq(family, "ipv4"))
639 hints.ai_family = AF_INET;
640 else if (streq(family, "ipv6"))
641 hints.ai_family = AF_INET6;
646 r = getaddrinfo(host, port, &hints, &result);
650 return -EADDRNOTAVAIL;
652 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
653 b->sockaddr_size = result->ai_addrlen;
655 freeaddrinfo(result);
660 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
662 unsigned n_argv = 0, j;
664 size_t allocated = 0;
672 while (**p != 0 && **p != ';') {
673 r = parse_address_key(p, "guid", guid);
679 r = parse_address_key(p, "path", &path);
685 if (startswith(*p, "argv")) {
689 ul = strtoul(*p + 4, (char**) p, 10);
690 if (errno > 0 || **p != '=' || ul > 256) {
698 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
706 r = parse_address_key(p, NULL, argv + ul);
721 /* Make sure there are no holes in the array, with the
722 * exception of argv[0] */
723 for (j = 1; j < n_argv; j++)
729 if (argv && argv[0] == NULL) {
730 argv[0] = strdup(path);
742 for (j = 0; j < n_argv; j++)
750 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
751 _cleanup_free_ char *path = NULL;
759 while (**p != 0 && **p != ';') {
760 r = parse_address_key(p, "guid", guid);
766 r = parse_address_key(p, "path", &path);
785 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
786 _cleanup_free_ char *machine = NULL, *pid = NULL;
794 while (**p != 0 && **p != ';') {
795 r = parse_address_key(p, "guid", guid);
801 r = parse_address_key(p, "machine", &machine);
807 r = parse_address_key(p, "pid", &pid);
816 if (!machine == !pid)
820 if (!machine_name_is_valid(machine))
824 b->machine = machine;
832 r = parse_pid(pid, &b->nspid);
838 b->sockaddr.un.sun_family = AF_UNIX;
839 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
840 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
845 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
846 _cleanup_free_ char *machine = NULL, *pid = NULL;
854 while (**p != 0 && **p != ';') {
855 r = parse_address_key(p, "guid", guid);
861 r = parse_address_key(p, "machine", &machine);
867 r = parse_address_key(p, "pid", &pid);
876 if (!machine == !pid)
880 if (!machine_name_is_valid(machine))
884 b->machine = machine;
892 r = parse_pid(pid, &b->nspid);
899 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
906 static void bus_reset_parsed_address(sd_bus *b) {
910 b->sockaddr_size = 0;
911 strv_free(b->exec_argv);
915 b->server_id = SD_ID128_NULL;
923 static int bus_parse_next_address(sd_bus *b) {
924 _cleanup_free_ char *guid = NULL;
932 if (b->address[b->address_index] == 0)
935 bus_reset_parsed_address(b);
937 a = b->address + b->address_index;
946 if (startswith(a, "unix:")) {
949 r = parse_unix_address(b, &a, &guid);
954 } else if (startswith(a, "tcp:")) {
957 r = parse_tcp_address(b, &a, &guid);
963 } else if (startswith(a, "unixexec:")) {
966 r = parse_exec_address(b, &a, &guid);
972 } else if (startswith(a, "kernel:")) {
975 r = parse_kernel_address(b, &a, &guid);
980 } else if (startswith(a, "x-machine-unix:")) {
983 r = parse_container_unix_address(b, &a, &guid);
988 } else if (startswith(a, "x-machine-kernel:")) {
991 r = parse_container_kernel_address(b, &a, &guid);
1004 r = sd_id128_from_string(guid, &b->server_id);
1009 b->address_index = a - b->address;
1013 static int bus_start_address(sd_bus *b) {
1019 bool skipped = false;
1024 r = bus_socket_exec(b);
1025 else if ((b->nspid > 0 || b->machine) && b->kernel)
1026 r = bus_container_connect_kernel(b);
1027 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1028 r = bus_container_connect_socket(b);
1030 r = bus_kernel_connect(b);
1031 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1032 r = bus_socket_connect(b);
1038 r = attach_io_events(b);
1043 b->last_connect_error = -r;
1046 r = bus_parse_next_address(b);
1050 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1054 int bus_next_address(sd_bus *b) {
1057 bus_reset_parsed_address(b);
1058 return bus_start_address(b);
1061 static int bus_start_fd(sd_bus *b) {
1066 assert(b->input_fd >= 0);
1067 assert(b->output_fd >= 0);
1069 r = fd_nonblock(b->input_fd, true);
1073 r = fd_cloexec(b->input_fd, true);
1077 if (b->input_fd != b->output_fd) {
1078 r = fd_nonblock(b->output_fd, true);
1082 r = fd_cloexec(b->output_fd, true);
1087 if (fstat(b->input_fd, &st) < 0)
1090 if (S_ISCHR(b->input_fd))
1091 return bus_kernel_take_fd(b);
1093 return bus_socket_take_fd(b);
1096 _public_ int sd_bus_start(sd_bus *bus) {
1099 assert_return(bus, -EINVAL);
1100 assert_return(bus->state == BUS_UNSET, -EPERM);
1101 assert_return(!bus_pid_changed(bus), -ECHILD);
1103 bus->state = BUS_OPENING;
1105 if (bus->is_server && bus->bus_client)
1108 if (bus->input_fd >= 0)
1109 r = bus_start_fd(bus);
1110 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1111 r = bus_start_address(bus);
1120 return bus_send_hello(bus);
1123 _public_ int sd_bus_open(sd_bus **ret) {
1128 assert_return(ret, -EINVAL);
1130 /* Let's connect to the starter bus if it is set, and
1131 * otherwise to the bus that is appropropriate for the scope
1132 * we are running in */
1134 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1136 if (streq(e, "system"))
1137 return sd_bus_open_system(ret);
1138 else if (STR_IN_SET(e, "session", "user"))
1139 return sd_bus_open_user(ret);
1142 e = secure_getenv("DBUS_STARTER_ADDRESS");
1144 return sd_bus_open_system(ret);
1151 r = sd_bus_set_address(b, e);
1155 b->bus_client = true;
1157 /* We don't know whether the bus is trusted or not, so better
1158 * be safe, and authenticate everything */
1160 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1161 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1163 r = sd_bus_start(b);
1175 int bus_set_address_system(sd_bus *b) {
1179 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1181 return sd_bus_set_address(b, e);
1183 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1186 _public_ int sd_bus_open_system(sd_bus **ret) {
1190 assert_return(ret, -EINVAL);
1196 r = bus_set_address_system(b);
1200 b->bus_client = true;
1201 b->is_system = true;
1203 /* Let's do per-method access control on the system bus. We
1204 * need the caller's UID and capability set for that. */
1206 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1207 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1209 r = sd_bus_start(b);
1221 int bus_set_address_user(sd_bus *b) {
1226 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1228 return sd_bus_set_address(b, e);
1230 e = secure_getenv("XDG_RUNTIME_DIR");
1232 _cleanup_free_ char *ee = NULL;
1234 ee = bus_address_escape(e);
1239 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1241 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1245 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1247 return -ECONNREFUSED;
1257 _public_ int sd_bus_open_user(sd_bus **ret) {
1261 assert_return(ret, -EINVAL);
1267 r = bus_set_address_user(b);
1271 b->bus_client = true;
1274 /* We don't do any per-method access control on the user
1278 r = sd_bus_start(b);
1290 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1291 _cleanup_free_ char *e = NULL;
1292 char *m = NULL, *c = NULL;
1297 /* Let's see if we shall enter some container */
1298 m = strchr(host, ':');
1302 /* Let's make sure this is not a port of some kind,
1303 * and is a valid machine name. */
1304 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1307 /* Cut out the host part */
1308 t = strndupa(host, m - host - 1);
1309 e = bus_address_escape(t);
1313 c = strjoina(",argv4=--machine=", m);
1318 e = bus_address_escape(host);
1323 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1330 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1334 assert_return(host, -EINVAL);
1335 assert_return(ret, -EINVAL);
1337 r = sd_bus_new(&bus);
1341 r = bus_set_address_system_remote(bus, host);
1345 bus->bus_client = true;
1346 bus->trusted = false;
1347 bus->is_system = true;
1349 r = sd_bus_start(bus);
1361 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1362 _cleanup_free_ char *e = NULL;
1367 e = bus_address_escape(machine);
1372 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1374 b->address = strjoin("x-machine-unix:machine=", e, NULL);
1382 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1386 assert_return(machine, -EINVAL);
1387 assert_return(ret, -EINVAL);
1388 assert_return(machine_name_is_valid(machine), -EINVAL);
1390 r = sd_bus_new(&bus);
1394 r = bus_set_address_system_machine(bus, machine);
1398 bus->bus_client = true;
1399 bus->trusted = false;
1400 bus->is_system = true;
1402 r = sd_bus_start(bus);
1414 _public_ void sd_bus_close(sd_bus *bus) {
1418 if (bus->state == BUS_CLOSED)
1420 if (bus_pid_changed(bus))
1423 bus->state = BUS_CLOSED;
1425 sd_bus_detach_event(bus);
1427 /* Drop all queued messages so that they drop references to
1428 * the bus object and the bus may be freed */
1429 bus_reset_queues(bus);
1431 if (!bus->is_kernel)
1434 /* We'll leave the fd open in case this is a kernel bus, since
1435 * there might still be memblocks around that reference this
1436 * bus, and they might need to invoke the KDBUS_CMD_FREE
1437 * ioctl on the fd when they are freed. */
1440 static void bus_enter_closing(sd_bus *bus) {
1443 if (bus->state != BUS_OPENING &&
1444 bus->state != BUS_AUTHENTICATING &&
1445 bus->state != BUS_HELLO &&
1446 bus->state != BUS_RUNNING)
1449 bus->state = BUS_CLOSING;
1452 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1453 assert_return(bus, NULL);
1455 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1460 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1466 i = REFCNT_DEC(bus->n_ref);
1474 _public_ int sd_bus_is_open(sd_bus *bus) {
1476 assert_return(bus, -EINVAL);
1477 assert_return(!bus_pid_changed(bus), -ECHILD);
1479 return BUS_IS_OPEN(bus->state);
1482 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1485 assert_return(bus, -EINVAL);
1486 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1487 assert_return(!bus_pid_changed(bus), -ECHILD);
1489 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1492 if (type == SD_BUS_TYPE_UNIX_FD) {
1493 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1496 r = bus_ensure_running(bus);
1500 return bus->can_fds;
1503 return bus_type_is_valid(type);
1506 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1509 assert_return(bus, -EINVAL);
1510 assert_return(id, -EINVAL);
1511 assert_return(!bus_pid_changed(bus), -ECHILD);
1513 r = bus_ensure_running(bus);
1517 *id = bus->server_id;
1521 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1526 /* If we copy the same message to multiple
1527 * destinations, avoid using the same cookie
1529 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1534 timeout = BUS_DEFAULT_TIMEOUT;
1536 return bus_message_seal(m, ++b->cookie, timeout);
1539 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1540 bool remarshal = false;
1544 /* wrong packet version */
1545 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1548 /* wrong packet endianness */
1549 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1552 /* TODO: kdbus-messages received from the kernel contain data which is
1553 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1554 * force remarshaling of the message. Technically, we could just
1555 * recreate the kdbus message, but that is non-trivial as other parts of
1556 * the message refer to m->kdbus already. This should be fixed! */
1557 if ((*m)->kdbus && (*m)->release_kdbus)
1560 return remarshal ? bus_message_remarshal(b, m) : 0;
1563 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1567 /* Fake some timestamps, if they were requested, and not
1568 * already initialized */
1569 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1570 if (m->realtime <= 0)
1571 m->realtime = now(CLOCK_REALTIME);
1573 if (m->monotonic <= 0)
1574 m->monotonic = now(CLOCK_MONOTONIC);
1577 /* The bus specification says the serial number cannot be 0,
1578 * hence let's fill something in for synthetic messages. Since
1579 * synthetic messages might have a fake sender and we don't
1580 * want to interfere with the real sender's serial numbers we
1581 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1582 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1583 * even though kdbus can do 64bit. */
1584 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1587 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1594 r = bus_kernel_write_message(bus, m, hint_sync_call);
1596 r = bus_socket_write_message(bus, m, idx);
1601 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1602 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1603 bus_message_type_to_string(m->header->type),
1604 strna(sd_bus_message_get_sender(m)),
1605 strna(sd_bus_message_get_destination(m)),
1606 strna(sd_bus_message_get_path(m)),
1607 strna(sd_bus_message_get_interface(m)),
1608 strna(sd_bus_message_get_member(m)),
1609 BUS_MESSAGE_COOKIE(m),
1611 strna(m->error.message));
1616 static int dispatch_wqueue(sd_bus *bus) {
1620 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1622 while (bus->wqueue_size > 0) {
1624 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1628 /* Didn't do anything this time */
1630 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1631 /* Fully written. Let's drop the entry from
1634 * This isn't particularly optimized, but
1635 * well, this is supposed to be our worst-case
1636 * buffer only, and the socket buffer is
1637 * supposed to be our primary buffer, and if
1638 * it got full, then all bets are off
1641 bus->wqueue_size --;
1642 sd_bus_message_unref(bus->wqueue[0]);
1643 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1653 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1657 return bus_kernel_read_message(bus, hint_priority, priority);
1659 return bus_socket_read_message(bus);
1662 int bus_rqueue_make_room(sd_bus *bus) {
1665 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1668 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1674 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1679 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1681 /* Note that the priority logic is only available on kdbus,
1682 * where the rqueue is unused. We check the rqueue here
1683 * anyway, because it's simple... */
1686 if (bus->rqueue_size > 0) {
1687 /* Dispatch a queued message */
1689 *m = bus->rqueue[0];
1690 bus->rqueue_size --;
1691 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1695 /* Try to read a new message */
1696 r = bus_read_message(bus, hint_priority, priority);
1706 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1707 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1710 assert_return(m, -EINVAL);
1715 assert_return(!bus_pid_changed(bus), -ECHILD);
1716 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1718 if (!BUS_IS_OPEN(bus->state))
1722 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1729 /* If the cookie number isn't kept, then we know that no reply
1731 if (!cookie && !m->sealed)
1732 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1734 r = bus_seal_message(bus, m, 0);
1738 /* Remarshall if we have to. This will possibly unref the
1739 * message and place a replacement in m */
1740 r = bus_remarshal_message(bus, &m);
1744 /* If this is a reply and no reply was requested, then let's
1745 * suppress this, if we can */
1749 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1752 r = bus_write_message(bus, m, hint_sync_call, &idx);
1754 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1755 bus_enter_closing(bus);
1762 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1763 /* Wasn't fully written. So let's remember how
1764 * much was written. Note that the first entry
1765 * of the wqueue array is always allocated so
1766 * that we always can remember how much was
1768 bus->wqueue[0] = sd_bus_message_ref(m);
1769 bus->wqueue_size = 1;
1774 /* Just append it to the queue. */
1776 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1779 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1782 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1787 *cookie = BUS_MESSAGE_COOKIE(m);
1792 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1793 return bus_send_internal(bus, m, cookie, false);
1796 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1799 assert_return(m, -EINVAL);
1804 assert_return(!bus_pid_changed(bus), -ECHILD);
1806 if (!BUS_IS_OPEN(bus->state))
1809 if (!streq_ptr(m->destination, destination)) {
1814 r = sd_bus_message_set_destination(m, destination);
1819 return sd_bus_send(bus, m, cookie);
1822 static usec_t calc_elapse(uint64_t usec) {
1823 if (usec == (uint64_t) -1)
1826 return now(CLOCK_MONOTONIC) + usec;
1829 static int timeout_compare(const void *a, const void *b) {
1830 const struct reply_callback *x = a, *y = b;
1832 if (x->timeout != 0 && y->timeout == 0)
1835 if (x->timeout == 0 && y->timeout != 0)
1838 if (x->timeout < y->timeout)
1841 if (x->timeout > y->timeout)
1847 _public_ int sd_bus_call_async(
1851 sd_bus_message_handler_t callback,
1855 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1856 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1859 assert_return(m, -EINVAL);
1860 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1861 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1862 assert_return(callback, -EINVAL);
1867 assert_return(!bus_pid_changed(bus), -ECHILD);
1868 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1870 if (!BUS_IS_OPEN(bus->state))
1873 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1877 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1881 r = bus_seal_message(bus, m, usec);
1885 r = bus_remarshal_message(bus, &m);
1889 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1893 s->reply_callback.callback = callback;
1895 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1896 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1898 s->reply_callback.cookie = 0;
1902 s->reply_callback.timeout = calc_elapse(m->timeout);
1903 if (s->reply_callback.timeout != 0) {
1904 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1906 s->reply_callback.timeout = 0;
1911 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1922 int bus_ensure_running(sd_bus *bus) {
1927 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1929 if (bus->state == BUS_RUNNING)
1933 r = sd_bus_process(bus, NULL);
1936 if (bus->state == BUS_RUNNING)
1941 r = sd_bus_wait(bus, (uint64_t) -1);
1947 _public_ int sd_bus_call(
1951 sd_bus_error *error,
1952 sd_bus_message **reply) {
1954 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1960 assert_return(m, -EINVAL);
1961 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1962 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1963 assert_return(!bus_error_is_dirty(error), -EINVAL);
1968 assert_return(!bus_pid_changed(bus), -ECHILD);
1969 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1971 if (!BUS_IS_OPEN(bus->state))
1974 r = bus_ensure_running(bus);
1978 i = bus->rqueue_size;
1980 r = bus_seal_message(bus, m, usec);
1984 r = bus_remarshal_message(bus, &m);
1988 r = bus_send_internal(bus, m, &cookie, true);
1992 timeout = calc_elapse(m->timeout);
1997 while (i < bus->rqueue_size) {
1998 sd_bus_message *incoming = NULL;
2000 incoming = bus->rqueue[i];
2002 if (incoming->reply_cookie == cookie) {
2003 /* Found a match! */
2005 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2007 log_debug_bus_message(incoming);
2009 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2011 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2015 sd_bus_message_unref(incoming);
2020 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2022 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
2023 r = sd_bus_error_copy(error, &incoming->error);
2027 sd_bus_message_unref(incoming);
2030 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2033 streq(bus->unique_name, incoming->sender)) {
2035 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2038 /* Our own message? Somebody is trying
2039 * to send its own client a message,
2040 * let's not dead-lock, let's fail
2043 sd_bus_message_unref(incoming);
2047 /* Try to read more, right-away */
2051 r = bus_read_message(bus, false, 0);
2053 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2054 bus_enter_closing(bus);
2066 n = now(CLOCK_MONOTONIC);
2072 left = (uint64_t) -1;
2074 r = bus_poll(bus, true, left);
2080 r = dispatch_wqueue(bus);
2082 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2083 bus_enter_closing(bus);
2092 _public_ int sd_bus_get_fd(sd_bus *bus) {
2094 assert_return(bus, -EINVAL);
2095 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2096 assert_return(!bus_pid_changed(bus), -ECHILD);
2098 return bus->input_fd;
2101 _public_ int sd_bus_get_events(sd_bus *bus) {
2104 assert_return(bus, -EINVAL);
2105 assert_return(!bus_pid_changed(bus), -ECHILD);
2107 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2110 if (bus->state == BUS_OPENING)
2112 else if (bus->state == BUS_AUTHENTICATING) {
2114 if (bus_socket_auth_needs_write(bus))
2119 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2120 if (bus->rqueue_size <= 0)
2122 if (bus->wqueue_size > 0)
2129 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2130 struct reply_callback *c;
2132 assert_return(bus, -EINVAL);
2133 assert_return(timeout_usec, -EINVAL);
2134 assert_return(!bus_pid_changed(bus), -ECHILD);
2136 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2139 if (bus->track_queue) {
2144 if (bus->state == BUS_CLOSING) {
2149 if (bus->state == BUS_AUTHENTICATING) {
2150 *timeout_usec = bus->auth_timeout;
2154 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2155 *timeout_usec = (uint64_t) -1;
2159 if (bus->rqueue_size > 0) {
2164 c = prioq_peek(bus->reply_callbacks_prioq);
2166 *timeout_usec = (uint64_t) -1;
2170 if (c->timeout == 0) {
2171 *timeout_usec = (uint64_t) -1;
2175 *timeout_usec = c->timeout;
2179 static int process_timeout(sd_bus *bus) {
2180 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2181 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2182 struct reply_callback *c;
2189 c = prioq_peek(bus->reply_callbacks_prioq);
2193 n = now(CLOCK_MONOTONIC);
2197 r = bus_message_new_synthetic_error(
2200 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2205 r = bus_seal_synthetic_message(bus, m);
2209 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2212 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2215 slot = container_of(c, sd_bus_slot, reply_callback);
2217 bus->iteration_counter ++;
2219 bus->current_message = m;
2220 bus->current_slot = sd_bus_slot_ref(slot);
2221 bus->current_handler = c->callback;
2222 bus->current_userdata = slot->userdata;
2223 r = c->callback(m, slot->userdata, &error_buffer);
2224 bus->current_userdata = NULL;
2225 bus->current_handler = NULL;
2226 bus->current_slot = NULL;
2227 bus->current_message = NULL;
2229 if (slot->floating) {
2230 bus_slot_disconnect(slot);
2231 sd_bus_slot_unref(slot);
2234 sd_bus_slot_unref(slot);
2236 return bus_maybe_reply_error(m, r, &error_buffer);
2239 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2243 if (bus->state != BUS_HELLO)
2246 /* Let's make sure the first message on the bus is the HELLO
2247 * reply. But note that we don't actually parse the message
2248 * here (we leave that to the usual handling), we just verify
2249 * we don't let any earlier msg through. */
2251 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2252 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2255 if (m->reply_cookie != 1)
2261 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2262 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2263 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2264 struct reply_callback *c;
2271 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2272 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2275 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2278 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2281 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2287 slot = container_of(c, sd_bus_slot, reply_callback);
2289 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2291 /* If the reply contained a file descriptor which we
2292 * didn't want we pass an error instead. */
2294 r = bus_message_new_synthetic_error(
2297 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2302 /* Copy over original timestamp */
2303 synthetic_reply->realtime = m->realtime;
2304 synthetic_reply->monotonic = m->monotonic;
2305 synthetic_reply->seqnum = m->seqnum;
2307 r = bus_seal_synthetic_message(bus, synthetic_reply);
2311 m = synthetic_reply;
2313 r = sd_bus_message_rewind(m, true);
2318 if (c->timeout != 0) {
2319 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2323 bus->current_slot = sd_bus_slot_ref(slot);
2324 bus->current_handler = c->callback;
2325 bus->current_userdata = slot->userdata;
2326 r = c->callback(m, slot->userdata, &error_buffer);
2327 bus->current_userdata = NULL;
2328 bus->current_handler = NULL;
2329 bus->current_slot = NULL;
2331 if (slot->floating) {
2332 bus_slot_disconnect(slot);
2333 sd_bus_slot_unref(slot);
2336 sd_bus_slot_unref(slot);
2338 return bus_maybe_reply_error(m, r, &error_buffer);
2341 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2342 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2343 struct filter_callback *l;
2350 bus->filter_callbacks_modified = false;
2352 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2355 if (bus->filter_callbacks_modified)
2358 /* Don't run this more than once per iteration */
2359 if (l->last_iteration == bus->iteration_counter)
2362 l->last_iteration = bus->iteration_counter;
2364 r = sd_bus_message_rewind(m, true);
2368 slot = container_of(l, sd_bus_slot, filter_callback);
2370 bus->current_slot = sd_bus_slot_ref(slot);
2371 bus->current_handler = l->callback;
2372 bus->current_userdata = slot->userdata;
2373 r = l->callback(m, slot->userdata, &error_buffer);
2374 bus->current_userdata = NULL;
2375 bus->current_handler = NULL;
2376 bus->current_slot = sd_bus_slot_unref(slot);
2378 r = bus_maybe_reply_error(m, r, &error_buffer);
2384 } while (bus->filter_callbacks_modified);
2389 static int process_match(sd_bus *bus, sd_bus_message *m) {
2396 bus->match_callbacks_modified = false;
2398 r = bus_match_run(bus, &bus->match_callbacks, m);
2402 } while (bus->match_callbacks_modified);
2407 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2408 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2414 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2417 if (bus->manual_peer_interface)
2420 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2423 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2426 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2429 if (streq_ptr(m->member, "Ping"))
2430 r = sd_bus_message_new_method_return(m, &reply);
2431 else if (streq_ptr(m->member, "GetMachineId")) {
2435 r = sd_id128_get_machine(&id);
2439 r = sd_bus_message_new_method_return(m, &reply);
2443 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2445 r = sd_bus_message_new_method_errorf(
2447 SD_BUS_ERROR_UNKNOWN_METHOD,
2448 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2454 r = sd_bus_send(bus, reply, NULL);
2461 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2465 /* If we got a message with a file descriptor which we didn't
2466 * want to accept, then let's drop it. How can this even
2467 * happen? For example, when the kernel queues a message into
2468 * an activatable names's queue which allows fds, and then is
2469 * delivered to us later even though we ourselves did not
2472 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2478 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2481 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2482 return 1; /* just eat it up */
2484 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2487 static int process_message(sd_bus *bus, sd_bus_message *m) {
2493 bus->current_message = m;
2494 bus->iteration_counter++;
2496 log_debug_bus_message(m);
2498 r = process_hello(bus, m);
2502 r = process_reply(bus, m);
2506 r = process_fd_check(bus, m);
2510 r = process_filter(bus, m);
2514 r = process_match(bus, m);
2518 r = process_builtin(bus, m);
2522 r = bus_process_object(bus, m);
2525 bus->current_message = NULL;
2529 static int dispatch_track(sd_bus *bus) {
2532 if (!bus->track_queue)
2535 bus_track_dispatch(bus->track_queue);
2539 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2540 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2544 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2546 r = process_timeout(bus);
2550 r = dispatch_wqueue(bus);
2554 r = dispatch_track(bus);
2558 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2564 r = process_message(bus, m);
2569 r = sd_bus_message_rewind(m, true);
2578 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2580 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2581 strna(sd_bus_message_get_sender(m)),
2582 strna(sd_bus_message_get_path(m)),
2583 strna(sd_bus_message_get_interface(m)),
2584 strna(sd_bus_message_get_member(m)));
2586 r = sd_bus_reply_method_errorf(
2588 SD_BUS_ERROR_UNKNOWN_OBJECT,
2589 "Unknown object '%s'.", m->path);
2603 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2604 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2605 struct reply_callback *c;
2609 assert(bus->state == BUS_CLOSING);
2611 c = ordered_hashmap_first(bus->reply_callbacks);
2613 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2616 /* First, fail all outstanding method calls */
2617 r = bus_message_new_synthetic_error(
2620 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2625 r = bus_seal_synthetic_message(bus, m);
2629 if (c->timeout != 0) {
2630 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2634 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2637 slot = container_of(c, sd_bus_slot, reply_callback);
2639 bus->iteration_counter++;
2641 bus->current_message = m;
2642 bus->current_slot = sd_bus_slot_ref(slot);
2643 bus->current_handler = c->callback;
2644 bus->current_userdata = slot->userdata;
2645 r = c->callback(m, slot->userdata, &error_buffer);
2646 bus->current_userdata = NULL;
2647 bus->current_handler = NULL;
2648 bus->current_slot = NULL;
2649 bus->current_message = NULL;
2651 if (slot->floating) {
2652 bus_slot_disconnect(slot);
2653 sd_bus_slot_unref(slot);
2656 sd_bus_slot_unref(slot);
2658 return bus_maybe_reply_error(m, r, &error_buffer);
2661 /* Then, synthesize a Disconnected message */
2662 r = sd_bus_message_new_signal(
2665 "/org/freedesktop/DBus/Local",
2666 "org.freedesktop.DBus.Local",
2671 bus_message_set_sender_local(bus, m);
2673 r = bus_seal_synthetic_message(bus, m);
2679 bus->current_message = m;
2680 bus->iteration_counter++;
2682 r = process_filter(bus, m);
2686 r = process_match(bus, m);
2698 bus->current_message = NULL;
2703 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2704 BUS_DONT_DESTROY(bus);
2707 /* Returns 0 when we didn't do anything. This should cause the
2708 * caller to invoke sd_bus_wait() before returning the next
2709 * time. Returns > 0 when we did something, which possibly
2710 * means *ret is filled in with an unprocessed message. */
2712 assert_return(bus, -EINVAL);
2713 assert_return(!bus_pid_changed(bus), -ECHILD);
2715 /* We don't allow recursively invoking sd_bus_process(). */
2716 assert_return(!bus->current_message, -EBUSY);
2717 assert(!bus->current_slot);
2719 switch (bus->state) {
2728 r = bus_socket_process_opening(bus);
2729 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2730 bus_enter_closing(bus);
2738 case BUS_AUTHENTICATING:
2739 r = bus_socket_process_authenticating(bus);
2740 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2741 bus_enter_closing(bus);
2753 r = process_running(bus, hint_priority, priority, ret);
2754 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2755 bus_enter_closing(bus);
2765 return process_closing(bus, ret);
2768 assert_not_reached("Unknown state");
2771 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2772 return bus_process_internal(bus, false, 0, ret);
2775 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2776 return bus_process_internal(bus, true, priority, ret);
2779 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2780 struct pollfd p[2] = {};
2783 usec_t m = USEC_INFINITY;
2787 if (bus->state == BUS_CLOSING)
2790 if (!BUS_IS_OPEN(bus->state))
2793 e = sd_bus_get_events(bus);
2798 /* The caller really needs some more data, he doesn't
2799 * care about what's already read, or any timeouts
2800 * except its own. */
2804 /* The caller wants to process if there's something to
2805 * process, but doesn't care otherwise */
2807 r = sd_bus_get_timeout(bus, &until);
2812 nw = now(CLOCK_MONOTONIC);
2813 m = until > nw ? until - nw : 0;
2817 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2820 p[0].fd = bus->input_fd;
2821 if (bus->output_fd == bus->input_fd) {
2825 p[0].events = e & POLLIN;
2826 p[1].fd = bus->output_fd;
2827 p[1].events = e & POLLOUT;
2831 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2835 return r > 0 ? 1 : 0;
2838 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2840 assert_return(bus, -EINVAL);
2841 assert_return(!bus_pid_changed(bus), -ECHILD);
2843 if (bus->state == BUS_CLOSING)
2846 if (!BUS_IS_OPEN(bus->state))
2849 if (bus->rqueue_size > 0)
2852 return bus_poll(bus, false, timeout_usec);
2855 _public_ int sd_bus_flush(sd_bus *bus) {
2858 assert_return(bus, -EINVAL);
2859 assert_return(!bus_pid_changed(bus), -ECHILD);
2861 if (bus->state == BUS_CLOSING)
2864 if (!BUS_IS_OPEN(bus->state))
2867 r = bus_ensure_running(bus);
2871 if (bus->wqueue_size <= 0)
2875 r = dispatch_wqueue(bus);
2877 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2878 bus_enter_closing(bus);
2885 if (bus->wqueue_size <= 0)
2888 r = bus_poll(bus, false, (uint64_t) -1);
2894 _public_ int sd_bus_add_filter(
2897 sd_bus_message_handler_t callback,
2902 assert_return(bus, -EINVAL);
2903 assert_return(callback, -EINVAL);
2904 assert_return(!bus_pid_changed(bus), -ECHILD);
2906 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2910 s->filter_callback.callback = callback;
2912 bus->filter_callbacks_modified = true;
2913 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2921 _public_ int sd_bus_add_match(
2925 sd_bus_message_handler_t callback,
2928 struct bus_match_component *components = NULL;
2929 unsigned n_components = 0;
2930 sd_bus_slot *s = NULL;
2933 assert_return(bus, -EINVAL);
2934 assert_return(match, -EINVAL);
2935 assert_return(!bus_pid_changed(bus), -ECHILD);
2937 r = bus_match_parse(match, &components, &n_components);
2941 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2947 s->match_callback.callback = callback;
2948 s->match_callback.cookie = ++bus->match_cookie;
2950 if (bus->bus_client) {
2952 if (!bus->is_kernel) {
2953 /* When this is not a kernel transport, we
2954 * store the original match string, so that we
2955 * can use it to remove the match again */
2957 s->match_callback.match_string = strdup(match);
2958 if (!s->match_callback.match_string) {
2964 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2969 bus->match_callbacks_modified = true;
2970 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2979 bus_match_parse_free(components, n_components);
2980 sd_bus_slot_unref(s);
2985 int bus_remove_match_by_string(
2988 sd_bus_message_handler_t callback,
2991 struct bus_match_component *components = NULL;
2992 unsigned n_components = 0;
2993 struct match_callback *c;
2996 assert_return(bus, -EINVAL);
2997 assert_return(match, -EINVAL);
2998 assert_return(!bus_pid_changed(bus), -ECHILD);
3000 r = bus_match_parse(match, &components, &n_components);
3004 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3008 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3011 bus_match_parse_free(components, n_components);
3016 bool bus_pid_changed(sd_bus *bus) {
3019 /* We don't support people creating a bus connection and
3020 * keeping it around over a fork(). Let's complain. */
3022 return bus->original_pid != getpid();
3025 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3026 sd_bus *bus = userdata;
3031 r = sd_bus_process(bus, NULL);
3038 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3039 sd_bus *bus = userdata;
3044 r = sd_bus_process(bus, NULL);
3051 static int prepare_callback(sd_event_source *s, void *userdata) {
3052 sd_bus *bus = userdata;
3059 e = sd_bus_get_events(bus);
3063 if (bus->output_fd != bus->input_fd) {
3065 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3069 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3073 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3078 r = sd_bus_get_timeout(bus, &until);
3084 j = sd_event_source_set_time(bus->time_event_source, until);
3089 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3096 static int quit_callback(sd_event_source *event, void *userdata) {
3097 sd_bus *bus = userdata;
3107 static int attach_io_events(sd_bus *bus) {
3112 if (bus->input_fd < 0)
3118 if (!bus->input_io_event_source) {
3119 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3123 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3127 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3131 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3133 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3138 if (bus->output_fd != bus->input_fd) {
3139 assert(bus->output_fd >= 0);
3141 if (!bus->output_io_event_source) {
3142 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3146 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3150 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3152 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3161 static void detach_io_events(sd_bus *bus) {
3164 if (bus->input_io_event_source) {
3165 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3166 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3169 if (bus->output_io_event_source) {
3170 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3171 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3175 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3178 assert_return(bus, -EINVAL);
3179 assert_return(!bus->event, -EBUSY);
3181 assert(!bus->input_io_event_source);
3182 assert(!bus->output_io_event_source);
3183 assert(!bus->time_event_source);
3186 bus->event = sd_event_ref(event);
3188 r = sd_event_default(&bus->event);
3193 bus->event_priority = priority;
3195 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3199 r = sd_event_source_set_priority(bus->time_event_source, priority);
3203 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3207 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3211 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3215 r = attach_io_events(bus);
3222 sd_bus_detach_event(bus);
3226 _public_ int sd_bus_detach_event(sd_bus *bus) {
3227 assert_return(bus, -EINVAL);
3232 detach_io_events(bus);
3234 if (bus->time_event_source) {
3235 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3236 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3239 if (bus->quit_event_source) {
3240 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3241 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3244 bus->event = sd_event_unref(bus->event);
3248 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3249 assert_return(bus, NULL);
3254 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3255 assert_return(bus, NULL);
3257 return bus->current_message;
3260 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3261 assert_return(bus, NULL);
3263 return bus->current_slot;
3266 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3267 assert_return(bus, NULL);
3269 return bus->current_handler;
3272 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3273 assert_return(bus, NULL);
3275 return bus->current_userdata;
3278 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3283 assert(default_bus);
3286 return !!*default_bus;
3289 *ret = sd_bus_ref(*default_bus);
3297 b->default_bus_ptr = default_bus;
3305 _public_ int sd_bus_default_system(sd_bus **ret) {
3306 static thread_local sd_bus *default_system_bus = NULL;
3308 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3311 _public_ int sd_bus_default_user(sd_bus **ret) {
3312 static thread_local sd_bus *default_user_bus = NULL;
3314 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3317 _public_ int sd_bus_default(sd_bus **ret) {
3321 /* Let's try our best to reuse another cached connection. If
3322 * the starter bus type is set, connect via our normal
3323 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3324 * we can share the connection with the user/system default
3327 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3329 if (streq(e, "system"))
3330 return sd_bus_default_system(ret);
3331 else if (STR_IN_SET(e, "user", "session"))
3332 return sd_bus_default_user(ret);
3335 /* No type is specified, so we have not other option than to
3336 * use the starter address if it is set. */
3338 e = secure_getenv("DBUS_STARTER_ADDRESS");
3340 static thread_local sd_bus *default_starter_bus = NULL;
3342 return bus_default(sd_bus_open, &default_starter_bus, ret);
3345 /* Finally, if nothing is set use the cached connection for
3346 * the right scope */
3348 return sd_bus_default_system(ret);
3351 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3352 assert_return(b, -EINVAL);
3353 assert_return(tid, -EINVAL);
3354 assert_return(!bus_pid_changed(b), -ECHILD);
3362 return sd_event_get_tid(b->event, tid);
3367 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3368 _cleanup_free_ char *e = NULL;
3371 assert_return(object_path_is_valid(prefix), -EINVAL);
3372 assert_return(external_id, -EINVAL);
3373 assert_return(ret_path, -EINVAL);
3375 e = bus_label_escape(external_id);
3379 ret = strjoin(prefix, "/", e, NULL);
3387 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3391 assert_return(object_path_is_valid(path), -EINVAL);
3392 assert_return(object_path_is_valid(prefix), -EINVAL);
3393 assert_return(external_id, -EINVAL);
3395 e = object_path_startswith(path, prefix);
3397 *external_id = NULL;
3401 ret = bus_label_unescape(e);
3409 _public_ int sd_bus_try_close(sd_bus *bus) {
3412 assert_return(bus, -EINVAL);
3413 assert_return(!bus_pid_changed(bus), -ECHILD);
3415 if (!bus->is_kernel)
3418 if (!BUS_IS_OPEN(bus->state))
3421 if (bus->rqueue_size > 0)
3424 if (bus->wqueue_size > 0)
3427 r = bus_kernel_try_close(bus);
3435 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3436 assert_return(bus, -EINVAL);
3437 assert_return(description, -EINVAL);
3438 assert_return(bus->description, -ENXIO);
3439 assert_return(!bus_pid_changed(bus), -ECHILD);
3441 *description = bus->description;
3445 int bus_get_root_path(sd_bus *bus) {
3448 if (bus->cgroup_root)
3451 r = cg_get_root_path(&bus->cgroup_root);
3453 bus->cgroup_root = strdup("/");
3454 if (!bus->cgroup_root)
3463 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3466 assert_return(bus, -EINVAL);
3467 assert_return(scope, -EINVAL);
3468 assert_return(!bus_pid_changed(bus), -ECHILD);
3470 if (bus->is_kernel) {
3471 _cleanup_free_ char *n = NULL;
3474 r = bus_kernel_get_bus_name(bus, &n);
3478 if (streq(n, "0-system")) {
3483 dash = strchr(n, '-');
3484 if (streq_ptr(dash, "-user")) {
3495 if (bus->is_system) {
3503 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3505 assert_return(bus, -EINVAL);
3506 assert_return(address, -EINVAL);
3507 assert_return(!bus_pid_changed(bus), -ECHILD);
3510 *address = bus->address;
3517 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3518 assert_return(bus, -EINVAL);
3519 assert_return(mask, -EINVAL);
3520 assert_return(!bus_pid_changed(bus), -ECHILD);
3522 *mask = bus->creds_mask;
3526 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3527 assert_return(bus, -EINVAL);
3528 assert_return(!bus_pid_changed(bus), -ECHILD);
3530 return bus->bus_client;
3533 _public_ int sd_bus_is_server(sd_bus *bus) {
3534 assert_return(bus, -EINVAL);
3535 assert_return(!bus_pid_changed(bus), -ECHILD);
3537 return bus->is_server;
3540 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3541 assert_return(bus, -EINVAL);
3542 assert_return(!bus_pid_changed(bus), -ECHILD);
3544 return bus->anonymous_auth;
3547 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3548 assert_return(bus, -EINVAL);
3549 assert_return(!bus_pid_changed(bus), -ECHILD);
3551 return bus->trusted;
3554 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3555 assert_return(bus, -EINVAL);
3556 assert_return(!bus_pid_changed(bus), -ECHILD);
3558 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);