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 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
53 static int attach_io_events(sd_bus *b);
54 static void detach_io_events(sd_bus *b);
56 static void bus_close_fds(sd_bus *b) {
62 safe_close(b->input_fd);
64 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
65 safe_close(b->output_fd);
67 b->input_fd = b->output_fd = -1;
70 static void bus_reset_queues(sd_bus *b) {
73 while (b->rqueue_size > 0)
74 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
78 b->rqueue_allocated = 0;
80 while (b->wqueue_size > 0)
81 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
85 b->wqueue_allocated = 0;
88 static void bus_free(sd_bus *b) {
92 assert(!b->track_queue);
94 b->state = BUS_CLOSED;
96 sd_bus_detach_event(b);
98 while ((s = b->slots)) {
99 /* At this point only floating slots can still be
100 * around, because the non-floating ones keep a
101 * reference to the bus, and we thus couldn't be
102 * destructing right now... We forcibly disconnect the
103 * slots here, so that they still can be referenced by
104 * apps, but are dead. */
107 bus_slot_disconnect(s);
108 sd_bus_slot_unref(s);
111 if (b->default_bus_ptr)
112 *b->default_bus_ptr = NULL;
117 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
120 free(b->unique_name);
121 free(b->auth_buffer);
126 free(b->cgroup_root);
127 free(b->description);
130 strv_free(b->exec_argv);
132 close_many(b->fds, b->n_fds);
137 ordered_hashmap_free_free(b->reply_callbacks);
138 prioq_free(b->reply_callbacks_prioq);
140 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
141 bus_match_free(&b->match_callbacks);
143 hashmap_free_free(b->vtable_methods);
144 hashmap_free_free(b->vtable_properties);
146 assert(hashmap_isempty(b->nodes));
147 hashmap_free(b->nodes);
149 bus_kernel_flush_memfd(b);
151 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
156 _public_ int sd_bus_new(sd_bus **ret) {
159 assert_return(ret, -EINVAL);
165 r->n_ref = REFCNT_INIT;
166 r->input_fd = r->output_fd = -1;
167 r->message_version = 1;
168 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
169 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
170 r->attach_flags |= KDBUS_ATTACH_NAMES;
171 r->original_pid = getpid();
173 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
175 /* We guarantee that wqueue always has space for at least one
177 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
186 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
189 assert_return(bus, -EINVAL);
190 assert_return(bus->state == BUS_UNSET, -EPERM);
191 assert_return(address, -EINVAL);
192 assert_return(!bus_pid_changed(bus), -ECHILD);
204 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
205 assert_return(bus, -EINVAL);
206 assert_return(bus->state == BUS_UNSET, -EPERM);
207 assert_return(input_fd >= 0, -EINVAL);
208 assert_return(output_fd >= 0, -EINVAL);
209 assert_return(!bus_pid_changed(bus), -ECHILD);
211 bus->input_fd = input_fd;
212 bus->output_fd = output_fd;
216 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
219 assert_return(bus, -EINVAL);
220 assert_return(bus->state == BUS_UNSET, -EPERM);
221 assert_return(path, -EINVAL);
222 assert_return(!strv_isempty(argv), -EINVAL);
223 assert_return(!bus_pid_changed(bus), -ECHILD);
235 free(bus->exec_path);
236 strv_free(bus->exec_argv);
244 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
245 assert_return(bus, -EINVAL);
246 assert_return(bus->state == BUS_UNSET, -EPERM);
247 assert_return(!bus_pid_changed(bus), -ECHILD);
249 bus->bus_client = !!b;
253 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
254 assert_return(bus, -EINVAL);
255 assert_return(bus->state == BUS_UNSET, -EPERM);
256 assert_return(!bus_pid_changed(bus), -ECHILD);
258 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
262 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
263 assert_return(bus, -EINVAL);
264 assert_return(bus->state == BUS_UNSET, -EPERM);
265 assert_return(!bus_pid_changed(bus), -ECHILD);
267 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
271 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
273 assert_return(bus, -EINVAL);
274 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
275 assert_return(!bus_pid_changed(bus), -ECHILD);
277 new_flags = bus->attach_flags;
278 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
280 if (bus->attach_flags == new_flags)
283 bus->attach_flags = new_flags;
284 if (bus->state != BUS_UNSET && bus->is_kernel)
285 bus_kernel_realize_attach_flags(bus);
290 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
293 assert_return(bus, -EINVAL);
294 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
295 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
296 assert_return(!bus_pid_changed(bus), -ECHILD);
299 bus->creds_mask |= mask;
301 bus->creds_mask &= ~mask;
303 /* The well knowns we need unconditionally, so that matches can work */
304 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
306 /* Make sure we don't lose the timestamp flag */
307 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
308 if (bus->attach_flags == new_flags)
311 bus->attach_flags = new_flags;
312 if (bus->state != BUS_UNSET && bus->is_kernel)
313 bus_kernel_realize_attach_flags(bus);
318 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
319 assert_return(bus, -EINVAL);
320 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
321 assert_return(bus->state == BUS_UNSET, -EPERM);
322 assert_return(!bus_pid_changed(bus), -ECHILD);
324 bus->is_server = !!b;
325 bus->server_id = server_id;
329 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
330 assert_return(bus, -EINVAL);
331 assert_return(bus->state == BUS_UNSET, -EPERM);
332 assert_return(!bus_pid_changed(bus), -ECHILD);
334 bus->anonymous_auth = !!b;
338 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
339 assert_return(bus, -EINVAL);
340 assert_return(bus->state == BUS_UNSET, -EPERM);
341 assert_return(!bus_pid_changed(bus), -ECHILD);
347 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
348 assert_return(bus, -EINVAL);
349 assert_return(bus->state == BUS_UNSET, -EPERM);
350 assert_return(!bus_pid_changed(bus), -ECHILD);
352 return free_and_strdup(&bus->description, description);
355 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
356 assert_return(bus, -EINVAL);
357 assert_return(!bus_pid_changed(bus), -ECHILD);
359 bus->allow_interactive_authorization = !!b;
363 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
364 assert_return(bus, -EINVAL);
365 assert_return(!bus_pid_changed(bus), -ECHILD);
367 return bus->allow_interactive_authorization;
370 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
375 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
378 r = sd_bus_message_get_errno(reply);
382 r = sd_bus_message_read(reply, "s", &s);
386 if (!service_name_is_valid(s) || s[0] != ':')
389 bus->unique_name = strdup(s);
390 if (!bus->unique_name)
393 if (bus->state == BUS_HELLO)
394 bus->state = BUS_RUNNING;
399 static int bus_send_hello(sd_bus *bus) {
400 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
405 if (!bus->bus_client || bus->is_kernel)
408 r = sd_bus_message_new_method_call(
411 "org.freedesktop.DBus",
412 "/org/freedesktop/DBus",
413 "org.freedesktop.DBus",
418 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
421 int bus_start_running(sd_bus *bus) {
424 if (bus->bus_client && !bus->is_kernel) {
425 bus->state = BUS_HELLO;
429 bus->state = BUS_RUNNING;
433 static int parse_address_key(const char **p, const char *key, char **value) {
434 size_t l, n = 0, allocated = 0;
444 if (strncmp(*p, key, l) != 0)
457 while (*a != ';' && *a != ',' && *a != 0) {
475 c = (char) ((x << 4) | y);
482 if (!GREEDY_REALLOC(r, allocated, n + 2))
506 static void skip_address_key(const char **p) {
510 *p += strcspn(*p, ",");
516 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
517 _cleanup_free_ char *path = NULL, *abstract = NULL;
526 while (**p != 0 && **p != ';') {
527 r = parse_address_key(p, "guid", guid);
533 r = parse_address_key(p, "path", &path);
539 r = parse_address_key(p, "abstract", &abstract);
548 if (!path && !abstract)
551 if (path && abstract)
556 if (l > sizeof(b->sockaddr.un.sun_path))
559 b->sockaddr.un.sun_family = AF_UNIX;
560 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
561 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
562 } else if (abstract) {
563 l = strlen(abstract);
564 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
567 b->sockaddr.un.sun_family = AF_UNIX;
568 b->sockaddr.un.sun_path[0] = 0;
569 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
570 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
576 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
577 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
579 struct addrinfo *result, hints = {
580 .ai_socktype = SOCK_STREAM,
581 .ai_flags = AI_ADDRCONFIG,
589 while (**p != 0 && **p != ';') {
590 r = parse_address_key(p, "guid", guid);
596 r = parse_address_key(p, "host", &host);
602 r = parse_address_key(p, "port", &port);
608 r = parse_address_key(p, "family", &family);
621 if (streq(family, "ipv4"))
622 hints.ai_family = AF_INET;
623 else if (streq(family, "ipv6"))
624 hints.ai_family = AF_INET6;
629 r = getaddrinfo(host, port, &hints, &result);
633 return -EADDRNOTAVAIL;
635 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
636 b->sockaddr_size = result->ai_addrlen;
638 freeaddrinfo(result);
643 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
645 unsigned n_argv = 0, j;
647 size_t allocated = 0;
655 while (**p != 0 && **p != ';') {
656 r = parse_address_key(p, "guid", guid);
662 r = parse_address_key(p, "path", &path);
668 if (startswith(*p, "argv")) {
672 ul = strtoul(*p + 4, (char**) p, 10);
673 if (errno > 0 || **p != '=' || ul > 256) {
681 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
689 r = parse_address_key(p, NULL, argv + ul);
704 /* Make sure there are no holes in the array, with the
705 * exception of argv[0] */
706 for (j = 1; j < n_argv; j++)
712 if (argv && argv[0] == NULL) {
713 argv[0] = strdup(path);
725 for (j = 0; j < n_argv; j++)
733 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
734 _cleanup_free_ char *path = NULL;
742 while (**p != 0 && **p != ';') {
743 r = parse_address_key(p, "guid", guid);
749 r = parse_address_key(p, "path", &path);
768 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
769 _cleanup_free_ char *machine = NULL, *pid = NULL;
777 while (**p != 0 && **p != ';') {
778 r = parse_address_key(p, "guid", guid);
784 r = parse_address_key(p, "machine", &machine);
790 r = parse_address_key(p, "pid", &pid);
799 if (!machine == !pid)
803 if (!machine_name_is_valid(machine))
807 b->machine = machine;
815 r = parse_pid(pid, &b->nspid);
821 b->sockaddr.un.sun_family = AF_UNIX;
822 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
823 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
828 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
829 _cleanup_free_ char *machine = NULL, *pid = NULL;
837 while (**p != 0 && **p != ';') {
838 r = parse_address_key(p, "guid", guid);
844 r = parse_address_key(p, "machine", &machine);
850 r = parse_address_key(p, "pid", &pid);
859 if (!machine == !pid)
863 if (!machine_name_is_valid(machine))
867 b->machine = machine;
875 r = parse_pid(pid, &b->nspid);
882 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
889 static void bus_reset_parsed_address(sd_bus *b) {
893 b->sockaddr_size = 0;
894 strv_free(b->exec_argv);
898 b->server_id = SD_ID128_NULL;
906 static int bus_parse_next_address(sd_bus *b) {
907 _cleanup_free_ char *guid = NULL;
915 if (b->address[b->address_index] == 0)
918 bus_reset_parsed_address(b);
920 a = b->address + b->address_index;
929 if (startswith(a, "unix:")) {
932 r = parse_unix_address(b, &a, &guid);
937 } else if (startswith(a, "tcp:")) {
940 r = parse_tcp_address(b, &a, &guid);
946 } else if (startswith(a, "unixexec:")) {
949 r = parse_exec_address(b, &a, &guid);
955 } else if (startswith(a, "kernel:")) {
958 r = parse_kernel_address(b, &a, &guid);
963 } else if (startswith(a, "x-machine-unix:")) {
966 r = parse_container_unix_address(b, &a, &guid);
971 } else if (startswith(a, "x-machine-kernel:")) {
974 r = parse_container_kernel_address(b, &a, &guid);
987 r = sd_id128_from_string(guid, &b->server_id);
992 b->address_index = a - b->address;
996 static int bus_start_address(sd_bus *b) {
1002 bool skipped = false;
1007 r = bus_socket_exec(b);
1008 else if ((b->nspid > 0 || b->machine) && b->kernel)
1009 r = bus_container_connect_kernel(b);
1010 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1011 r = bus_container_connect_socket(b);
1013 r = bus_kernel_connect(b);
1014 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1015 r = bus_socket_connect(b);
1021 r = attach_io_events(b);
1026 b->last_connect_error = -r;
1029 r = bus_parse_next_address(b);
1033 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1037 int bus_next_address(sd_bus *b) {
1040 bus_reset_parsed_address(b);
1041 return bus_start_address(b);
1044 static int bus_start_fd(sd_bus *b) {
1049 assert(b->input_fd >= 0);
1050 assert(b->output_fd >= 0);
1052 r = fd_nonblock(b->input_fd, true);
1056 r = fd_cloexec(b->input_fd, true);
1060 if (b->input_fd != b->output_fd) {
1061 r = fd_nonblock(b->output_fd, true);
1065 r = fd_cloexec(b->output_fd, true);
1070 if (fstat(b->input_fd, &st) < 0)
1073 if (S_ISCHR(b->input_fd))
1074 return bus_kernel_take_fd(b);
1076 return bus_socket_take_fd(b);
1079 _public_ int sd_bus_start(sd_bus *bus) {
1082 assert_return(bus, -EINVAL);
1083 assert_return(bus->state == BUS_UNSET, -EPERM);
1084 assert_return(!bus_pid_changed(bus), -ECHILD);
1086 bus->state = BUS_OPENING;
1088 if (bus->is_server && bus->bus_client)
1091 if (bus->input_fd >= 0)
1092 r = bus_start_fd(bus);
1093 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1094 r = bus_start_address(bus);
1103 return bus_send_hello(bus);
1106 _public_ int sd_bus_open(sd_bus **ret) {
1111 assert_return(ret, -EINVAL);
1113 /* Let's connect to the starter bus if it is set, and
1114 * otherwise to the bus that is appropropriate for the scope
1115 * we are running in */
1117 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1119 if (streq(e, "system"))
1120 return sd_bus_open_system(ret);
1121 else if (STR_IN_SET(e, "session", "user"))
1122 return sd_bus_open_user(ret);
1125 e = secure_getenv("DBUS_STARTER_ADDRESS");
1127 return sd_bus_open_system(ret);
1134 r = sd_bus_set_address(b, e);
1138 b->bus_client = true;
1140 /* We don't know whether the bus is trusted or not, so better
1141 * be safe, and authenticate everything */
1143 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1144 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1146 r = sd_bus_start(b);
1158 int bus_set_address_system(sd_bus *b) {
1162 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1164 return sd_bus_set_address(b, e);
1166 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1169 _public_ int sd_bus_open_system(sd_bus **ret) {
1173 assert_return(ret, -EINVAL);
1179 r = bus_set_address_system(b);
1183 b->bus_client = true;
1184 b->is_system = true;
1186 /* Let's do per-method access control on the system bus. We
1187 * need the caller's UID and capability set for that. */
1189 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1190 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1192 r = sd_bus_start(b);
1204 int bus_set_address_user(sd_bus *b) {
1209 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1211 return sd_bus_set_address(b, e);
1213 e = secure_getenv("XDG_RUNTIME_DIR");
1215 _cleanup_free_ char *ee = NULL;
1217 ee = bus_address_escape(e);
1222 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1224 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1228 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1230 return -ECONNREFUSED;
1240 _public_ int sd_bus_open_user(sd_bus **ret) {
1244 assert_return(ret, -EINVAL);
1250 r = bus_set_address_user(b);
1254 b->bus_client = true;
1257 /* We don't do any per-method access control on the user
1261 r = sd_bus_start(b);
1273 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1274 _cleanup_free_ char *e = NULL;
1275 char *m = NULL, *c = NULL;
1280 /* Let's see if we shall enter some container */
1281 m = strchr(host, ':');
1285 /* Let's make sure this is not a port of some kind,
1286 * and is a valid machine name. */
1287 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1290 /* Cut out the host part */
1291 t = strndupa(host, m - host - 1);
1292 e = bus_address_escape(t);
1296 c = strjoina(",argv4=--machine=", m);
1301 e = bus_address_escape(host);
1306 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1313 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1317 assert_return(host, -EINVAL);
1318 assert_return(ret, -EINVAL);
1320 r = sd_bus_new(&bus);
1324 r = bus_set_address_system_remote(bus, host);
1328 bus->bus_client = true;
1329 bus->trusted = false;
1330 bus->is_system = true;
1332 r = sd_bus_start(bus);
1344 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1345 _cleanup_free_ char *e = NULL;
1350 e = bus_address_escape(machine);
1355 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1357 b->address = strjoin("x-machine-unix:machine=", e, NULL);
1365 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1369 assert_return(machine, -EINVAL);
1370 assert_return(ret, -EINVAL);
1371 assert_return(machine_name_is_valid(machine), -EINVAL);
1373 r = sd_bus_new(&bus);
1377 r = bus_set_address_system_machine(bus, machine);
1381 bus->bus_client = true;
1382 bus->trusted = false;
1383 bus->is_system = true;
1385 r = sd_bus_start(bus);
1397 _public_ void sd_bus_close(sd_bus *bus) {
1401 if (bus->state == BUS_CLOSED)
1403 if (bus_pid_changed(bus))
1406 bus->state = BUS_CLOSED;
1408 sd_bus_detach_event(bus);
1410 /* Drop all queued messages so that they drop references to
1411 * the bus object and the bus may be freed */
1412 bus_reset_queues(bus);
1414 if (!bus->is_kernel)
1417 /* We'll leave the fd open in case this is a kernel bus, since
1418 * there might still be memblocks around that reference this
1419 * bus, and they might need to invoke the KDBUS_CMD_FREE
1420 * ioctl on the fd when they are freed. */
1423 static void bus_enter_closing(sd_bus *bus) {
1426 if (bus->state != BUS_OPENING &&
1427 bus->state != BUS_AUTHENTICATING &&
1428 bus->state != BUS_HELLO &&
1429 bus->state != BUS_RUNNING)
1432 bus->state = BUS_CLOSING;
1435 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1436 assert_return(bus, NULL);
1438 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1443 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1449 i = REFCNT_DEC(bus->n_ref);
1457 _public_ int sd_bus_is_open(sd_bus *bus) {
1459 assert_return(bus, -EINVAL);
1460 assert_return(!bus_pid_changed(bus), -ECHILD);
1462 return BUS_IS_OPEN(bus->state);
1465 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1468 assert_return(bus, -EINVAL);
1469 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1470 assert_return(!bus_pid_changed(bus), -ECHILD);
1472 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1475 if (type == SD_BUS_TYPE_UNIX_FD) {
1476 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1479 r = bus_ensure_running(bus);
1483 return bus->can_fds;
1486 return bus_type_is_valid(type);
1489 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1492 assert_return(bus, -EINVAL);
1493 assert_return(id, -EINVAL);
1494 assert_return(!bus_pid_changed(bus), -ECHILD);
1496 r = bus_ensure_running(bus);
1500 *id = bus->server_id;
1504 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1509 /* If we copy the same message to multiple
1510 * destinations, avoid using the same cookie
1512 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1517 timeout = BUS_DEFAULT_TIMEOUT;
1519 return bus_message_seal(m, ++b->cookie, timeout);
1522 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1523 bool remarshal = false;
1527 /* wrong packet version */
1528 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1531 /* wrong packet endianness */
1532 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1535 /* TODO: kdbus-messages received from the kernel contain data which is
1536 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1537 * force remarshaling of the message. Technically, we could just
1538 * recreate the kdbus message, but that is non-trivial as other parts of
1539 * the message refer to m->kdbus already. This should be fixed! */
1540 if ((*m)->kdbus && (*m)->release_kdbus)
1543 return remarshal ? bus_message_remarshal(b, m) : 0;
1546 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1550 /* Fake some timestamps, if they were requested, and not
1551 * already initialized */
1552 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1553 if (m->realtime <= 0)
1554 m->realtime = now(CLOCK_REALTIME);
1556 if (m->monotonic <= 0)
1557 m->monotonic = now(CLOCK_MONOTONIC);
1560 /* The bus specification says the serial number cannot be 0,
1561 * hence let's fill something in for synthetic messages. Since
1562 * synthetic messages might have a fake sender and we don't
1563 * want to interfere with the real sender's serial numbers we
1564 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1565 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1566 * even though kdbus can do 64bit. */
1567 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1570 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1577 r = bus_kernel_write_message(bus, m, hint_sync_call);
1579 r = bus_socket_write_message(bus, m, idx);
1584 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1585 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1586 bus_message_type_to_string(m->header->type),
1587 strna(sd_bus_message_get_sender(m)),
1588 strna(sd_bus_message_get_destination(m)),
1589 strna(sd_bus_message_get_path(m)),
1590 strna(sd_bus_message_get_interface(m)),
1591 strna(sd_bus_message_get_member(m)),
1592 BUS_MESSAGE_COOKIE(m),
1594 strna(m->error.message));
1599 static int dispatch_wqueue(sd_bus *bus) {
1603 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1605 while (bus->wqueue_size > 0) {
1607 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1611 /* Didn't do anything this time */
1613 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1614 /* Fully written. Let's drop the entry from
1617 * This isn't particularly optimized, but
1618 * well, this is supposed to be our worst-case
1619 * buffer only, and the socket buffer is
1620 * supposed to be our primary buffer, and if
1621 * it got full, then all bets are off
1624 bus->wqueue_size --;
1625 sd_bus_message_unref(bus->wqueue[0]);
1626 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1636 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1640 return bus_kernel_read_message(bus, hint_priority, priority);
1642 return bus_socket_read_message(bus);
1645 int bus_rqueue_make_room(sd_bus *bus) {
1648 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1651 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1657 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1662 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1664 /* Note that the priority logic is only available on kdbus,
1665 * where the rqueue is unused. We check the rqueue here
1666 * anyway, because it's simple... */
1669 if (bus->rqueue_size > 0) {
1670 /* Dispatch a queued message */
1672 *m = bus->rqueue[0];
1673 bus->rqueue_size --;
1674 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1678 /* Try to read a new message */
1679 r = bus_read_message(bus, hint_priority, priority);
1689 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1690 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1693 assert_return(bus, -EINVAL);
1694 assert_return(m, -EINVAL);
1695 assert_return(!bus_pid_changed(bus), -ECHILD);
1696 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1698 if (!BUS_IS_OPEN(bus->state))
1702 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1709 /* If the cookie number isn't kept, then we know that no reply
1711 if (!cookie && !m->sealed)
1712 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1714 r = bus_seal_message(bus, m, 0);
1718 /* Remarshall if we have to. This will possibly unref the
1719 * message and place a replacement in m */
1720 r = bus_remarshal_message(bus, &m);
1724 /* If this is a reply and no reply was requested, then let's
1725 * suppress this, if we can */
1729 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1732 r = bus_write_message(bus, m, hint_sync_call, &idx);
1734 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1735 bus_enter_closing(bus);
1742 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1743 /* Wasn't fully written. So let's remember how
1744 * much was written. Note that the first entry
1745 * of the wqueue array is always allocated so
1746 * that we always can remember how much was
1748 bus->wqueue[0] = sd_bus_message_ref(m);
1749 bus->wqueue_size = 1;
1754 /* Just append it to the queue. */
1756 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1759 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1762 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1767 *cookie = BUS_MESSAGE_COOKIE(m);
1772 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1773 return bus_send_internal(bus, m, cookie, false);
1776 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1779 assert_return(bus, -EINVAL);
1780 assert_return(m, -EINVAL);
1781 assert_return(!bus_pid_changed(bus), -ECHILD);
1783 if (!BUS_IS_OPEN(bus->state))
1786 if (!streq_ptr(m->destination, destination)) {
1791 r = sd_bus_message_set_destination(m, destination);
1796 return sd_bus_send(bus, m, cookie);
1799 static usec_t calc_elapse(uint64_t usec) {
1800 if (usec == (uint64_t) -1)
1803 return now(CLOCK_MONOTONIC) + usec;
1806 static int timeout_compare(const void *a, const void *b) {
1807 const struct reply_callback *x = a, *y = b;
1809 if (x->timeout != 0 && y->timeout == 0)
1812 if (x->timeout == 0 && y->timeout != 0)
1815 if (x->timeout < y->timeout)
1818 if (x->timeout > y->timeout)
1824 _public_ int sd_bus_call_async(
1828 sd_bus_message_handler_t callback,
1832 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1833 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1836 assert_return(bus, -EINVAL);
1837 assert_return(m, -EINVAL);
1838 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1839 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1840 assert_return(callback, -EINVAL);
1841 assert_return(!bus_pid_changed(bus), -ECHILD);
1842 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1844 if (!BUS_IS_OPEN(bus->state))
1847 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1851 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1855 r = bus_seal_message(bus, m, usec);
1859 r = bus_remarshal_message(bus, &m);
1863 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1867 s->reply_callback.callback = callback;
1869 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1870 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1872 s->reply_callback.cookie = 0;
1876 s->reply_callback.timeout = calc_elapse(m->timeout);
1877 if (s->reply_callback.timeout != 0) {
1878 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1880 s->reply_callback.timeout = 0;
1885 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1896 int bus_ensure_running(sd_bus *bus) {
1901 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1903 if (bus->state == BUS_RUNNING)
1907 r = sd_bus_process(bus, NULL);
1910 if (bus->state == BUS_RUNNING)
1915 r = sd_bus_wait(bus, (uint64_t) -1);
1921 _public_ int sd_bus_call(
1925 sd_bus_error *error,
1926 sd_bus_message **reply) {
1928 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1934 assert_return(bus, -EINVAL);
1935 assert_return(m, -EINVAL);
1936 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1937 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1938 assert_return(!bus_error_is_dirty(error), -EINVAL);
1939 assert_return(!bus_pid_changed(bus), -ECHILD);
1940 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1942 if (!BUS_IS_OPEN(bus->state))
1945 r = bus_ensure_running(bus);
1949 i = bus->rqueue_size;
1951 r = bus_seal_message(bus, m, usec);
1955 r = bus_remarshal_message(bus, &m);
1959 r = bus_send_internal(bus, m, &cookie, true);
1963 timeout = calc_elapse(m->timeout);
1968 while (i < bus->rqueue_size) {
1969 sd_bus_message *incoming = NULL;
1971 incoming = bus->rqueue[i];
1973 if (incoming->reply_cookie == cookie) {
1974 /* Found a match! */
1976 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1979 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1981 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1985 sd_bus_message_unref(incoming);
1990 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1992 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1993 r = sd_bus_error_copy(error, &incoming->error);
1997 sd_bus_message_unref(incoming);
2000 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2003 streq(bus->unique_name, incoming->sender)) {
2005 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2008 /* Our own message? Somebody is trying
2009 * to send its own client a message,
2010 * let's not dead-lock, let's fail
2013 sd_bus_message_unref(incoming);
2017 /* Try to read more, right-away */
2021 r = bus_read_message(bus, false, 0);
2023 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2024 bus_enter_closing(bus);
2036 n = now(CLOCK_MONOTONIC);
2042 left = (uint64_t) -1;
2044 r = bus_poll(bus, true, left);
2050 r = dispatch_wqueue(bus);
2052 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2053 bus_enter_closing(bus);
2062 _public_ int sd_bus_get_fd(sd_bus *bus) {
2064 assert_return(bus, -EINVAL);
2065 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2066 assert_return(!bus_pid_changed(bus), -ECHILD);
2068 return bus->input_fd;
2071 _public_ int sd_bus_get_events(sd_bus *bus) {
2074 assert_return(bus, -EINVAL);
2075 assert_return(!bus_pid_changed(bus), -ECHILD);
2077 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2080 if (bus->state == BUS_OPENING)
2082 else if (bus->state == BUS_AUTHENTICATING) {
2084 if (bus_socket_auth_needs_write(bus))
2089 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2090 if (bus->rqueue_size <= 0)
2092 if (bus->wqueue_size > 0)
2099 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2100 struct reply_callback *c;
2102 assert_return(bus, -EINVAL);
2103 assert_return(timeout_usec, -EINVAL);
2104 assert_return(!bus_pid_changed(bus), -ECHILD);
2106 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2109 if (bus->track_queue) {
2114 if (bus->state == BUS_CLOSING) {
2119 if (bus->state == BUS_AUTHENTICATING) {
2120 *timeout_usec = bus->auth_timeout;
2124 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2125 *timeout_usec = (uint64_t) -1;
2129 if (bus->rqueue_size > 0) {
2134 c = prioq_peek(bus->reply_callbacks_prioq);
2136 *timeout_usec = (uint64_t) -1;
2140 if (c->timeout == 0) {
2141 *timeout_usec = (uint64_t) -1;
2145 *timeout_usec = c->timeout;
2149 static int process_timeout(sd_bus *bus) {
2150 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2151 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2152 struct reply_callback *c;
2159 c = prioq_peek(bus->reply_callbacks_prioq);
2163 n = now(CLOCK_MONOTONIC);
2167 r = bus_message_new_synthetic_error(
2170 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2175 r = bus_seal_synthetic_message(bus, m);
2179 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2182 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2185 slot = container_of(c, sd_bus_slot, reply_callback);
2187 bus->iteration_counter ++;
2189 bus->current_message = m;
2190 bus->current_slot = sd_bus_slot_ref(slot);
2191 bus->current_handler = c->callback;
2192 bus->current_userdata = slot->userdata;
2193 r = c->callback(bus, m, slot->userdata, &error_buffer);
2194 bus->current_userdata = NULL;
2195 bus->current_handler = NULL;
2196 bus->current_slot = NULL;
2197 bus->current_message = NULL;
2199 if (slot->floating) {
2200 bus_slot_disconnect(slot);
2201 sd_bus_slot_unref(slot);
2204 sd_bus_slot_unref(slot);
2206 return bus_maybe_reply_error(m, r, &error_buffer);
2209 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2213 if (bus->state != BUS_HELLO)
2216 /* Let's make sure the first message on the bus is the HELLO
2217 * reply. But note that we don't actually parse the message
2218 * here (we leave that to the usual handling), we just verify
2219 * we don't let any earlier msg through. */
2221 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2222 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2225 if (m->reply_cookie != 1)
2231 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2232 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2233 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2234 struct reply_callback *c;
2241 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2242 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2245 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2248 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2251 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2257 slot = container_of(c, sd_bus_slot, reply_callback);
2259 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2261 /* If the reply contained a file descriptor which we
2262 * didn't want we pass an error instead. */
2264 r = bus_message_new_synthetic_error(
2267 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2272 /* Copy over original timestamp */
2273 synthetic_reply->realtime = m->realtime;
2274 synthetic_reply->monotonic = m->monotonic;
2275 synthetic_reply->seqnum = m->seqnum;
2277 r = bus_seal_synthetic_message(bus, synthetic_reply);
2281 m = synthetic_reply;
2283 r = sd_bus_message_rewind(m, true);
2288 if (c->timeout != 0) {
2289 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2293 bus->current_slot = sd_bus_slot_ref(slot);
2294 bus->current_handler = c->callback;
2295 bus->current_userdata = slot->userdata;
2296 r = c->callback(bus, m, slot->userdata, &error_buffer);
2297 bus->current_userdata = NULL;
2298 bus->current_handler = NULL;
2299 bus->current_slot = NULL;
2301 if (slot->floating) {
2302 bus_slot_disconnect(slot);
2303 sd_bus_slot_unref(slot);
2306 sd_bus_slot_unref(slot);
2308 return bus_maybe_reply_error(m, r, &error_buffer);
2311 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2312 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2313 struct filter_callback *l;
2320 bus->filter_callbacks_modified = false;
2322 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2325 if (bus->filter_callbacks_modified)
2328 /* Don't run this more than once per iteration */
2329 if (l->last_iteration == bus->iteration_counter)
2332 l->last_iteration = bus->iteration_counter;
2334 r = sd_bus_message_rewind(m, true);
2338 slot = container_of(l, sd_bus_slot, filter_callback);
2340 bus->current_slot = sd_bus_slot_ref(slot);
2341 bus->current_handler = l->callback;
2342 bus->current_userdata = slot->userdata;
2343 r = l->callback(bus, m, slot->userdata, &error_buffer);
2344 bus->current_userdata = NULL;
2345 bus->current_handler = NULL;
2346 bus->current_slot = sd_bus_slot_unref(slot);
2348 r = bus_maybe_reply_error(m, r, &error_buffer);
2354 } while (bus->filter_callbacks_modified);
2359 static int process_match(sd_bus *bus, sd_bus_message *m) {
2366 bus->match_callbacks_modified = false;
2368 r = bus_match_run(bus, &bus->match_callbacks, m);
2372 } while (bus->match_callbacks_modified);
2377 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2378 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2384 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2387 if (bus->manual_peer_interface)
2390 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2393 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2396 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2399 if (streq_ptr(m->member, "Ping"))
2400 r = sd_bus_message_new_method_return(m, &reply);
2401 else if (streq_ptr(m->member, "GetMachineId")) {
2405 r = sd_id128_get_machine(&id);
2409 r = sd_bus_message_new_method_return(m, &reply);
2413 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2415 r = sd_bus_message_new_method_errorf(
2417 SD_BUS_ERROR_UNKNOWN_METHOD,
2418 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2424 r = sd_bus_send(bus, reply, NULL);
2431 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2435 /* If we got a message with a file descriptor which we didn't
2436 * want to accept, then let's drop it. How can this even
2437 * happen? For example, when the kernel queues a message into
2438 * an activatable names's queue which allows fds, and then is
2439 * delivered to us later even though we ourselves did not
2442 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2448 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2451 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2452 return 1; /* just eat it up */
2454 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2457 static int process_message(sd_bus *bus, sd_bus_message *m) {
2463 bus->current_message = m;
2464 bus->iteration_counter++;
2466 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2467 bus_message_type_to_string(m->header->type),
2468 strna(sd_bus_message_get_sender(m)),
2469 strna(sd_bus_message_get_destination(m)),
2470 strna(sd_bus_message_get_path(m)),
2471 strna(sd_bus_message_get_interface(m)),
2472 strna(sd_bus_message_get_member(m)),
2473 BUS_MESSAGE_COOKIE(m),
2475 strna(m->error.message));
2477 r = process_hello(bus, m);
2481 r = process_reply(bus, m);
2485 r = process_fd_check(bus, m);
2489 r = process_filter(bus, m);
2493 r = process_match(bus, m);
2497 r = process_builtin(bus, m);
2501 r = bus_process_object(bus, m);
2504 bus->current_message = NULL;
2508 static int dispatch_track(sd_bus *bus) {
2511 if (!bus->track_queue)
2514 bus_track_dispatch(bus->track_queue);
2518 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2519 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2523 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2525 r = process_timeout(bus);
2529 r = dispatch_wqueue(bus);
2533 r = dispatch_track(bus);
2537 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2543 r = process_message(bus, m);
2548 r = sd_bus_message_rewind(m, true);
2557 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2559 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2560 strna(sd_bus_message_get_sender(m)),
2561 strna(sd_bus_message_get_path(m)),
2562 strna(sd_bus_message_get_interface(m)),
2563 strna(sd_bus_message_get_member(m)));
2565 r = sd_bus_reply_method_errorf(
2567 SD_BUS_ERROR_UNKNOWN_OBJECT,
2568 "Unknown object '%s'.", m->path);
2582 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2583 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2584 struct reply_callback *c;
2588 assert(bus->state == BUS_CLOSING);
2590 c = ordered_hashmap_first(bus->reply_callbacks);
2592 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2595 /* First, fail all outstanding method calls */
2596 r = bus_message_new_synthetic_error(
2599 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2604 r = bus_seal_synthetic_message(bus, m);
2608 if (c->timeout != 0) {
2609 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2613 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2616 slot = container_of(c, sd_bus_slot, reply_callback);
2618 bus->iteration_counter++;
2620 bus->current_message = m;
2621 bus->current_slot = sd_bus_slot_ref(slot);
2622 bus->current_handler = c->callback;
2623 bus->current_userdata = slot->userdata;
2624 r = c->callback(bus, m, slot->userdata, &error_buffer);
2625 bus->current_userdata = NULL;
2626 bus->current_handler = NULL;
2627 bus->current_slot = NULL;
2628 bus->current_message = NULL;
2630 if (slot->floating) {
2631 bus_slot_disconnect(slot);
2632 sd_bus_slot_unref(slot);
2635 sd_bus_slot_unref(slot);
2637 return bus_maybe_reply_error(m, r, &error_buffer);
2640 /* Then, synthesize a Disconnected message */
2641 r = sd_bus_message_new_signal(
2644 "/org/freedesktop/DBus/Local",
2645 "org.freedesktop.DBus.Local",
2650 bus_message_set_sender_local(bus, m);
2652 r = bus_seal_synthetic_message(bus, m);
2658 bus->current_message = m;
2659 bus->iteration_counter++;
2661 r = process_filter(bus, m);
2665 r = process_match(bus, m);
2677 bus->current_message = NULL;
2682 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2683 BUS_DONT_DESTROY(bus);
2686 /* Returns 0 when we didn't do anything. This should cause the
2687 * caller to invoke sd_bus_wait() before returning the next
2688 * time. Returns > 0 when we did something, which possibly
2689 * means *ret is filled in with an unprocessed message. */
2691 assert_return(bus, -EINVAL);
2692 assert_return(!bus_pid_changed(bus), -ECHILD);
2694 /* We don't allow recursively invoking sd_bus_process(). */
2695 assert_return(!bus->current_message, -EBUSY);
2696 assert(!bus->current_slot);
2698 switch (bus->state) {
2707 r = bus_socket_process_opening(bus);
2708 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2709 bus_enter_closing(bus);
2717 case BUS_AUTHENTICATING:
2718 r = bus_socket_process_authenticating(bus);
2719 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2720 bus_enter_closing(bus);
2732 r = process_running(bus, hint_priority, priority, ret);
2733 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2734 bus_enter_closing(bus);
2744 return process_closing(bus, ret);
2747 assert_not_reached("Unknown state");
2750 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2751 return bus_process_internal(bus, false, 0, ret);
2754 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2755 return bus_process_internal(bus, true, priority, ret);
2758 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2759 struct pollfd p[2] = {};
2762 usec_t m = USEC_INFINITY;
2766 if (bus->state == BUS_CLOSING)
2769 if (!BUS_IS_OPEN(bus->state))
2772 e = sd_bus_get_events(bus);
2777 /* The caller really needs some more data, he doesn't
2778 * care about what's already read, or any timeouts
2779 * except its own. */
2783 /* The caller wants to process if there's something to
2784 * process, but doesn't care otherwise */
2786 r = sd_bus_get_timeout(bus, &until);
2791 nw = now(CLOCK_MONOTONIC);
2792 m = until > nw ? until - nw : 0;
2796 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2799 p[0].fd = bus->input_fd;
2800 if (bus->output_fd == bus->input_fd) {
2804 p[0].events = e & POLLIN;
2805 p[1].fd = bus->output_fd;
2806 p[1].events = e & POLLOUT;
2810 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2814 return r > 0 ? 1 : 0;
2817 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2819 assert_return(bus, -EINVAL);
2820 assert_return(!bus_pid_changed(bus), -ECHILD);
2822 if (bus->state == BUS_CLOSING)
2825 if (!BUS_IS_OPEN(bus->state))
2828 if (bus->rqueue_size > 0)
2831 return bus_poll(bus, false, timeout_usec);
2834 _public_ int sd_bus_flush(sd_bus *bus) {
2837 assert_return(bus, -EINVAL);
2838 assert_return(!bus_pid_changed(bus), -ECHILD);
2840 if (bus->state == BUS_CLOSING)
2843 if (!BUS_IS_OPEN(bus->state))
2846 r = bus_ensure_running(bus);
2850 if (bus->wqueue_size <= 0)
2854 r = dispatch_wqueue(bus);
2856 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2857 bus_enter_closing(bus);
2864 if (bus->wqueue_size <= 0)
2867 r = bus_poll(bus, false, (uint64_t) -1);
2873 _public_ int sd_bus_add_filter(
2876 sd_bus_message_handler_t callback,
2881 assert_return(bus, -EINVAL);
2882 assert_return(callback, -EINVAL);
2883 assert_return(!bus_pid_changed(bus), -ECHILD);
2885 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2889 s->filter_callback.callback = callback;
2891 bus->filter_callbacks_modified = true;
2892 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2900 _public_ int sd_bus_add_match(
2904 sd_bus_message_handler_t callback,
2907 struct bus_match_component *components = NULL;
2908 unsigned n_components = 0;
2909 sd_bus_slot *s = NULL;
2912 assert_return(bus, -EINVAL);
2913 assert_return(match, -EINVAL);
2914 assert_return(!bus_pid_changed(bus), -ECHILD);
2916 r = bus_match_parse(match, &components, &n_components);
2920 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2926 s->match_callback.callback = callback;
2927 s->match_callback.cookie = ++bus->match_cookie;
2929 if (bus->bus_client) {
2931 if (!bus->is_kernel) {
2932 /* When this is not a kernel transport, we
2933 * store the original match string, so that we
2934 * can use it to remove the match again */
2936 s->match_callback.match_string = strdup(match);
2937 if (!s->match_callback.match_string) {
2943 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2948 bus->match_callbacks_modified = true;
2949 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2958 bus_match_parse_free(components, n_components);
2959 sd_bus_slot_unref(s);
2964 int bus_remove_match_by_string(
2967 sd_bus_message_handler_t callback,
2970 struct bus_match_component *components = NULL;
2971 unsigned n_components = 0;
2972 struct match_callback *c;
2975 assert_return(bus, -EINVAL);
2976 assert_return(match, -EINVAL);
2977 assert_return(!bus_pid_changed(bus), -ECHILD);
2979 r = bus_match_parse(match, &components, &n_components);
2983 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2987 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2990 bus_match_parse_free(components, n_components);
2995 bool bus_pid_changed(sd_bus *bus) {
2998 /* We don't support people creating a bus connection and
2999 * keeping it around over a fork(). Let's complain. */
3001 return bus->original_pid != getpid();
3004 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3005 sd_bus *bus = userdata;
3010 r = sd_bus_process(bus, NULL);
3017 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3018 sd_bus *bus = userdata;
3023 r = sd_bus_process(bus, NULL);
3030 static int prepare_callback(sd_event_source *s, void *userdata) {
3031 sd_bus *bus = userdata;
3038 e = sd_bus_get_events(bus);
3042 if (bus->output_fd != bus->input_fd) {
3044 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3048 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3052 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3057 r = sd_bus_get_timeout(bus, &until);
3063 j = sd_event_source_set_time(bus->time_event_source, until);
3068 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3075 static int quit_callback(sd_event_source *event, void *userdata) {
3076 sd_bus *bus = userdata;
3086 static int attach_io_events(sd_bus *bus) {
3091 if (bus->input_fd < 0)
3097 if (!bus->input_io_event_source) {
3098 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3102 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3106 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3110 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3112 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3117 if (bus->output_fd != bus->input_fd) {
3118 assert(bus->output_fd >= 0);
3120 if (!bus->output_io_event_source) {
3121 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3125 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3129 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3131 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3140 static void detach_io_events(sd_bus *bus) {
3143 if (bus->input_io_event_source) {
3144 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3145 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3148 if (bus->output_io_event_source) {
3149 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3150 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3154 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3157 assert_return(bus, -EINVAL);
3158 assert_return(!bus->event, -EBUSY);
3160 assert(!bus->input_io_event_source);
3161 assert(!bus->output_io_event_source);
3162 assert(!bus->time_event_source);
3165 bus->event = sd_event_ref(event);
3167 r = sd_event_default(&bus->event);
3172 bus->event_priority = priority;
3174 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3178 r = sd_event_source_set_priority(bus->time_event_source, priority);
3182 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3186 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3190 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3194 r = attach_io_events(bus);
3201 sd_bus_detach_event(bus);
3205 _public_ int sd_bus_detach_event(sd_bus *bus) {
3206 assert_return(bus, -EINVAL);
3211 detach_io_events(bus);
3213 if (bus->time_event_source) {
3214 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3215 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3218 if (bus->quit_event_source) {
3219 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3220 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3223 bus->event = sd_event_unref(bus->event);
3227 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3228 assert_return(bus, NULL);
3233 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3234 assert_return(bus, NULL);
3236 return bus->current_message;
3239 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3240 assert_return(bus, NULL);
3242 return bus->current_slot;
3245 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3246 assert_return(bus, NULL);
3248 return bus->current_handler;
3251 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3252 assert_return(bus, NULL);
3254 return bus->current_userdata;
3257 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3262 assert(default_bus);
3265 return !!*default_bus;
3268 *ret = sd_bus_ref(*default_bus);
3276 b->default_bus_ptr = default_bus;
3284 _public_ int sd_bus_default_system(sd_bus **ret) {
3285 static thread_local sd_bus *default_system_bus = NULL;
3287 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3290 _public_ int sd_bus_default_user(sd_bus **ret) {
3291 static thread_local sd_bus *default_user_bus = NULL;
3293 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3296 _public_ int sd_bus_default(sd_bus **ret) {
3300 /* Let's try our best to reuse another cached connection. If
3301 * the starter bus type is set, connect via our normal
3302 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3303 * we can share the connection with the user/system default
3306 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3308 if (streq(e, "system"))
3309 return sd_bus_default_system(ret);
3310 else if (STR_IN_SET(e, "user", "session"))
3311 return sd_bus_default_user(ret);
3314 /* No type is specified, so we have not other option than to
3315 * use the starter address if it is set. */
3317 e = secure_getenv("DBUS_STARTER_ADDRESS");
3319 static thread_local sd_bus *default_starter_bus = NULL;
3321 return bus_default(sd_bus_open, &default_starter_bus, ret);
3324 /* Finally, if nothing is set use the cached connection for
3325 * the right scope */
3327 return sd_bus_default_system(ret);
3330 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3331 assert_return(b, -EINVAL);
3332 assert_return(tid, -EINVAL);
3333 assert_return(!bus_pid_changed(b), -ECHILD);
3341 return sd_event_get_tid(b->event, tid);
3346 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3347 _cleanup_free_ char *e = NULL;
3350 assert_return(object_path_is_valid(prefix), -EINVAL);
3351 assert_return(external_id, -EINVAL);
3352 assert_return(ret_path, -EINVAL);
3354 e = bus_label_escape(external_id);
3358 ret = strjoin(prefix, "/", e, NULL);
3366 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3370 assert_return(object_path_is_valid(path), -EINVAL);
3371 assert_return(object_path_is_valid(prefix), -EINVAL);
3372 assert_return(external_id, -EINVAL);
3374 e = object_path_startswith(path, prefix);
3376 *external_id = NULL;
3380 ret = bus_label_unescape(e);
3388 _public_ int sd_bus_try_close(sd_bus *bus) {
3391 assert_return(bus, -EINVAL);
3392 assert_return(!bus_pid_changed(bus), -ECHILD);
3394 if (!bus->is_kernel)
3397 if (!BUS_IS_OPEN(bus->state))
3400 if (bus->rqueue_size > 0)
3403 if (bus->wqueue_size > 0)
3406 r = bus_kernel_try_close(bus);
3414 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3415 assert_return(bus, -EINVAL);
3416 assert_return(description, -EINVAL);
3417 assert_return(bus->description, -ENXIO);
3418 assert_return(!bus_pid_changed(bus), -ECHILD);
3420 *description = bus->description;
3424 int bus_get_root_path(sd_bus *bus) {
3427 if (bus->cgroup_root)
3430 r = cg_get_root_path(&bus->cgroup_root);
3432 bus->cgroup_root = strdup("/");
3433 if (!bus->cgroup_root)
3442 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3445 assert_return(bus, -EINVAL);
3446 assert_return(scope, -EINVAL);
3447 assert_return(!bus_pid_changed(bus), -ECHILD);
3449 if (bus->is_kernel) {
3450 _cleanup_free_ char *n = NULL;
3453 r = bus_kernel_get_bus_name(bus, &n);
3457 if (streq(n, "0-system")) {
3462 dash = strchr(n, '-');
3463 if (streq_ptr(dash, "-user")) {
3474 if (bus->is_system) {
3482 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3484 assert_return(bus, -EINVAL);
3485 assert_return(address, -EINVAL);
3486 assert_return(!bus_pid_changed(bus), -ECHILD);
3489 *address = bus->address;
3496 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3497 assert_return(bus, -EINVAL);
3498 assert_return(mask, -EINVAL);
3499 assert_return(!bus_pid_changed(bus), -ECHILD);
3501 *mask = bus->creds_mask;
3505 int sd_bus_is_bus_client(sd_bus *bus) {
3506 assert_return(bus, -EINVAL);
3507 assert_return(!bus_pid_changed(bus), -ECHILD);
3509 return bus->bus_client;
3512 int sd_bus_is_server(sd_bus *bus) {
3513 assert_return(bus, -EINVAL);
3514 assert_return(!bus_pid_changed(bus), -ECHILD);
3516 return bus->is_server;
3519 int sd_bus_is_anonymous(sd_bus *bus) {
3520 assert_return(bus, -EINVAL);
3521 assert_return(!bus_pid_changed(bus), -ECHILD);
3523 return bus->anonymous_auth;
3526 int sd_bus_is_trusted(sd_bus *bus) {
3527 assert_return(bus, -EINVAL);
3528 assert_return(!bus_pid_changed(bus), -ECHILD);
3530 return bus->trusted;
3533 int sd_bus_is_monitor(sd_bus *bus) {
3534 assert_return(bus, -EINVAL);
3535 assert_return(!bus_pid_changed(bus), -ECHILD);
3537 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);