1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
35 #include "cgroup-util.h"
36 #include "bus-label.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
42 #include "bus-socket.h"
43 #include "bus-kernel.h"
44 #include "bus-control.h"
45 #include "bus-objects.h"
47 #include "bus-container.h"
48 #include "bus-protocol.h"
49 #include "bus-track.h"
52 #define log_debug_bus_message(m) \
54 sd_bus_message *_mm = (m); \
55 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
56 bus_message_type_to_string(_mm->header->type), \
57 strna(sd_bus_message_get_sender(_mm)), \
58 strna(sd_bus_message_get_destination(_mm)), \
59 strna(sd_bus_message_get_path(_mm)), \
60 strna(sd_bus_message_get_interface(_mm)), \
61 strna(sd_bus_message_get_member(_mm)), \
62 BUS_MESSAGE_COOKIE(_mm), \
64 strna(_mm->error.message)); \
67 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
68 static int attach_io_events(sd_bus *b);
69 static void detach_io_events(sd_bus *b);
71 static void bus_close_fds(sd_bus *b) {
77 safe_close(b->input_fd);
79 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
80 safe_close(b->output_fd);
82 b->input_fd = b->output_fd = -1;
85 static void bus_reset_queues(sd_bus *b) {
88 while (b->rqueue_size > 0)
89 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
93 b->rqueue_allocated = 0;
95 while (b->wqueue_size > 0)
96 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
100 b->wqueue_allocated = 0;
103 static void bus_free(sd_bus *b) {
107 assert(!b->track_queue);
109 b->state = BUS_CLOSED;
111 sd_bus_detach_event(b);
113 while ((s = b->slots)) {
114 /* At this point only floating slots can still be
115 * around, because the non-floating ones keep a
116 * reference to the bus, and we thus couldn't be
117 * destructing right now... We forcibly disconnect the
118 * slots here, so that they still can be referenced by
119 * apps, but are dead. */
122 bus_slot_disconnect(s);
123 sd_bus_slot_unref(s);
126 if (b->default_bus_ptr)
127 *b->default_bus_ptr = NULL;
132 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
136 free(b->unique_name);
137 free(b->auth_buffer);
142 free(b->cgroup_root);
143 free(b->description);
146 strv_free(b->exec_argv);
148 close_many(b->fds, b->n_fds);
153 ordered_hashmap_free_free(b->reply_callbacks);
154 prioq_free(b->reply_callbacks_prioq);
156 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
157 bus_match_free(&b->match_callbacks);
159 hashmap_free_free(b->vtable_methods);
160 hashmap_free_free(b->vtable_properties);
162 assert(hashmap_isempty(b->nodes));
163 hashmap_free(b->nodes);
165 bus_kernel_flush_memfd(b);
167 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
172 _public_ int sd_bus_new(sd_bus **ret) {
175 assert_return(ret, -EINVAL);
181 r->n_ref = REFCNT_INIT;
182 r->input_fd = r->output_fd = -1;
183 r->message_version = 1;
184 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
185 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
186 r->attach_flags |= KDBUS_ATTACH_NAMES;
187 r->original_pid = getpid();
189 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
191 /* We guarantee that wqueue always has space for at least one
193 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
202 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
205 assert_return(bus, -EINVAL);
206 assert_return(bus->state == BUS_UNSET, -EPERM);
207 assert_return(address, -EINVAL);
208 assert_return(!bus_pid_changed(bus), -ECHILD);
220 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
221 assert_return(bus, -EINVAL);
222 assert_return(bus->state == BUS_UNSET, -EPERM);
223 assert_return(input_fd >= 0, -EINVAL);
224 assert_return(output_fd >= 0, -EINVAL);
225 assert_return(!bus_pid_changed(bus), -ECHILD);
227 bus->input_fd = input_fd;
228 bus->output_fd = output_fd;
232 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
235 assert_return(bus, -EINVAL);
236 assert_return(bus->state == BUS_UNSET, -EPERM);
237 assert_return(path, -EINVAL);
238 assert_return(!strv_isempty(argv), -EINVAL);
239 assert_return(!bus_pid_changed(bus), -ECHILD);
251 free(bus->exec_path);
252 strv_free(bus->exec_argv);
260 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
261 assert_return(bus, -EINVAL);
262 assert_return(bus->state == BUS_UNSET, -EPERM);
263 assert_return(!bus_pid_changed(bus), -ECHILD);
265 bus->bus_client = !!b;
269 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
270 assert_return(bus, -EINVAL);
271 assert_return(bus->state == BUS_UNSET, -EPERM);
272 assert_return(!bus_pid_changed(bus), -ECHILD);
274 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
278 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
279 assert_return(bus, -EINVAL);
280 assert_return(bus->state == BUS_UNSET, -EPERM);
281 assert_return(!bus_pid_changed(bus), -ECHILD);
283 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
287 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
289 assert_return(bus, -EINVAL);
290 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
291 assert_return(!bus_pid_changed(bus), -ECHILD);
293 new_flags = bus->attach_flags;
294 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
296 if (bus->attach_flags == new_flags)
299 bus->attach_flags = new_flags;
300 if (bus->state != BUS_UNSET && bus->is_kernel)
301 bus_kernel_realize_attach_flags(bus);
306 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
309 assert_return(bus, -EINVAL);
310 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
311 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
312 assert_return(!bus_pid_changed(bus), -ECHILD);
315 bus->creds_mask |= mask;
317 bus->creds_mask &= ~mask;
319 /* The well knowns we need unconditionally, so that matches can work */
320 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
322 /* Make sure we don't lose the timestamp flag */
323 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
324 if (bus->attach_flags == new_flags)
327 bus->attach_flags = new_flags;
328 if (bus->state != BUS_UNSET && bus->is_kernel)
329 bus_kernel_realize_attach_flags(bus);
334 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
335 assert_return(bus, -EINVAL);
336 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
337 assert_return(bus->state == BUS_UNSET, -EPERM);
338 assert_return(!bus_pid_changed(bus), -ECHILD);
340 bus->is_server = !!b;
341 bus->server_id = server_id;
345 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
346 assert_return(bus, -EINVAL);
347 assert_return(bus->state == BUS_UNSET, -EPERM);
348 assert_return(!bus_pid_changed(bus), -ECHILD);
350 bus->anonymous_auth = !!b;
354 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
355 assert_return(bus, -EINVAL);
356 assert_return(bus->state == BUS_UNSET, -EPERM);
357 assert_return(!bus_pid_changed(bus), -ECHILD);
363 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
364 assert_return(bus, -EINVAL);
365 assert_return(bus->state == BUS_UNSET, -EPERM);
366 assert_return(!bus_pid_changed(bus), -ECHILD);
368 return free_and_strdup(&bus->description, description);
371 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
372 assert_return(bus, -EINVAL);
373 assert_return(!bus_pid_changed(bus), -ECHILD);
375 bus->allow_interactive_authorization = !!b;
379 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
380 assert_return(bus, -EINVAL);
381 assert_return(!bus_pid_changed(bus), -ECHILD);
383 return bus->allow_interactive_authorization;
386 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
394 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
396 r = sd_bus_message_get_errno(reply);
400 r = sd_bus_message_read(reply, "s", &s);
404 if (!service_name_is_valid(s) || s[0] != ':')
407 bus->unique_name = strdup(s);
408 if (!bus->unique_name)
411 if (bus->state == BUS_HELLO)
412 bus->state = BUS_RUNNING;
417 static int bus_send_hello(sd_bus *bus) {
418 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
423 if (!bus->bus_client || bus->is_kernel)
426 r = sd_bus_message_new_method_call(
429 "org.freedesktop.DBus",
430 "/org/freedesktop/DBus",
431 "org.freedesktop.DBus",
436 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
439 int bus_start_running(sd_bus *bus) {
442 if (bus->bus_client && !bus->is_kernel) {
443 bus->state = BUS_HELLO;
447 bus->state = BUS_RUNNING;
451 static int parse_address_key(const char **p, const char *key, char **value) {
452 size_t l, n = 0, allocated = 0;
462 if (strncmp(*p, key, l) != 0)
475 while (*a != ';' && *a != ',' && *a != 0) {
493 c = (char) ((x << 4) | y);
500 if (!GREEDY_REALLOC(r, allocated, n + 2))
524 static void skip_address_key(const char **p) {
528 *p += strcspn(*p, ",");
534 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
535 _cleanup_free_ char *path = NULL, *abstract = NULL;
544 while (**p != 0 && **p != ';') {
545 r = parse_address_key(p, "guid", guid);
551 r = parse_address_key(p, "path", &path);
557 r = parse_address_key(p, "abstract", &abstract);
566 if (!path && !abstract)
569 if (path && abstract)
574 if (l > sizeof(b->sockaddr.un.sun_path))
577 b->sockaddr.un.sun_family = AF_UNIX;
578 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
579 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
580 } else if (abstract) {
581 l = strlen(abstract);
582 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
585 b->sockaddr.un.sun_family = AF_UNIX;
586 b->sockaddr.un.sun_path[0] = 0;
587 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
588 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
594 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
595 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
597 struct addrinfo *result, hints = {
598 .ai_socktype = SOCK_STREAM,
599 .ai_flags = AI_ADDRCONFIG,
607 while (**p != 0 && **p != ';') {
608 r = parse_address_key(p, "guid", guid);
614 r = parse_address_key(p, "host", &host);
620 r = parse_address_key(p, "port", &port);
626 r = parse_address_key(p, "family", &family);
639 if (streq(family, "ipv4"))
640 hints.ai_family = AF_INET;
641 else if (streq(family, "ipv6"))
642 hints.ai_family = AF_INET6;
647 r = getaddrinfo(host, port, &hints, &result);
651 return -EADDRNOTAVAIL;
653 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
654 b->sockaddr_size = result->ai_addrlen;
656 freeaddrinfo(result);
661 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
663 unsigned n_argv = 0, j;
665 size_t allocated = 0;
673 while (**p != 0 && **p != ';') {
674 r = parse_address_key(p, "guid", guid);
680 r = parse_address_key(p, "path", &path);
686 if (startswith(*p, "argv")) {
690 ul = strtoul(*p + 4, (char**) p, 10);
691 if (errno > 0 || **p != '=' || ul > 256) {
699 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
707 r = parse_address_key(p, NULL, argv + ul);
722 /* Make sure there are no holes in the array, with the
723 * exception of argv[0] */
724 for (j = 1; j < n_argv; j++)
730 if (argv && argv[0] == NULL) {
731 argv[0] = strdup(path);
743 for (j = 0; j < n_argv; j++)
751 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
752 _cleanup_free_ char *path = NULL;
760 while (**p != 0 && **p != ';') {
761 r = parse_address_key(p, "guid", guid);
767 r = parse_address_key(p, "path", &path);
786 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
787 _cleanup_free_ char *machine = NULL, *pid = NULL;
795 while (**p != 0 && **p != ';') {
796 r = parse_address_key(p, "guid", guid);
802 r = parse_address_key(p, "machine", &machine);
808 r = parse_address_key(p, "pid", &pid);
817 if (!machine == !pid)
821 if (!machine_name_is_valid(machine))
825 b->machine = machine;
833 r = parse_pid(pid, &b->nspid);
839 b->sockaddr.un.sun_family = AF_UNIX;
840 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
841 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
846 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
847 _cleanup_free_ char *machine = NULL, *pid = NULL;
855 while (**p != 0 && **p != ';') {
856 r = parse_address_key(p, "guid", guid);
862 r = parse_address_key(p, "machine", &machine);
868 r = parse_address_key(p, "pid", &pid);
877 if (!machine == !pid)
881 if (!machine_name_is_valid(machine))
885 b->machine = machine;
893 r = parse_pid(pid, &b->nspid);
900 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
907 static void bus_reset_parsed_address(sd_bus *b) {
911 b->sockaddr_size = 0;
912 strv_free(b->exec_argv);
916 b->server_id = SD_ID128_NULL;
924 static int bus_parse_next_address(sd_bus *b) {
925 _cleanup_free_ char *guid = NULL;
933 if (b->address[b->address_index] == 0)
936 bus_reset_parsed_address(b);
938 a = b->address + b->address_index;
947 if (startswith(a, "unix:")) {
950 r = parse_unix_address(b, &a, &guid);
955 } else if (startswith(a, "tcp:")) {
958 r = parse_tcp_address(b, &a, &guid);
964 } else if (startswith(a, "unixexec:")) {
967 r = parse_exec_address(b, &a, &guid);
973 } else if (startswith(a, "kernel:")) {
976 r = parse_kernel_address(b, &a, &guid);
981 } else if (startswith(a, "x-machine-unix:")) {
984 r = parse_container_unix_address(b, &a, &guid);
989 } else if (startswith(a, "x-machine-kernel:")) {
992 r = parse_container_kernel_address(b, &a, &guid);
1005 r = sd_id128_from_string(guid, &b->server_id);
1010 b->address_index = a - b->address;
1014 static int bus_start_address(sd_bus *b) {
1020 bool skipped = false;
1025 r = bus_socket_exec(b);
1026 else if ((b->nspid > 0 || b->machine) && b->kernel)
1027 r = bus_container_connect_kernel(b);
1028 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1029 r = bus_container_connect_socket(b);
1031 r = bus_kernel_connect(b);
1032 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1033 r = bus_socket_connect(b);
1039 r = attach_io_events(b);
1044 b->last_connect_error = -r;
1047 r = bus_parse_next_address(b);
1051 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1055 int bus_next_address(sd_bus *b) {
1058 bus_reset_parsed_address(b);
1059 return bus_start_address(b);
1062 static int bus_start_fd(sd_bus *b) {
1067 assert(b->input_fd >= 0);
1068 assert(b->output_fd >= 0);
1070 r = fd_nonblock(b->input_fd, true);
1074 r = fd_cloexec(b->input_fd, true);
1078 if (b->input_fd != b->output_fd) {
1079 r = fd_nonblock(b->output_fd, true);
1083 r = fd_cloexec(b->output_fd, true);
1088 if (fstat(b->input_fd, &st) < 0)
1091 if (S_ISCHR(b->input_fd))
1092 return bus_kernel_take_fd(b);
1094 return bus_socket_take_fd(b);
1097 _public_ int sd_bus_start(sd_bus *bus) {
1100 assert_return(bus, -EINVAL);
1101 assert_return(bus->state == BUS_UNSET, -EPERM);
1102 assert_return(!bus_pid_changed(bus), -ECHILD);
1104 bus->state = BUS_OPENING;
1106 if (bus->is_server && bus->bus_client)
1109 if (bus->input_fd >= 0)
1110 r = bus_start_fd(bus);
1111 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1112 r = bus_start_address(bus);
1121 return bus_send_hello(bus);
1124 _public_ int sd_bus_open(sd_bus **ret) {
1129 assert_return(ret, -EINVAL);
1131 /* Let's connect to the starter bus if it is set, and
1132 * otherwise to the bus that is appropropriate for the scope
1133 * we are running in */
1135 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1137 if (streq(e, "system"))
1138 return sd_bus_open_system(ret);
1139 else if (STR_IN_SET(e, "session", "user"))
1140 return sd_bus_open_user(ret);
1143 e = secure_getenv("DBUS_STARTER_ADDRESS");
1145 return sd_bus_open_system(ret);
1152 r = sd_bus_set_address(b, e);
1156 b->bus_client = true;
1158 /* We don't know whether the bus is trusted or not, so better
1159 * be safe, and authenticate everything */
1161 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1162 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1164 r = sd_bus_start(b);
1176 int bus_set_address_system(sd_bus *b) {
1180 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1182 return sd_bus_set_address(b, e);
1184 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1187 _public_ int sd_bus_open_system(sd_bus **ret) {
1191 assert_return(ret, -EINVAL);
1197 r = bus_set_address_system(b);
1201 b->bus_client = true;
1202 b->is_system = true;
1204 /* Let's do per-method access control on the system bus. We
1205 * need the caller's UID and capability set for that. */
1207 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1208 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1210 r = sd_bus_start(b);
1222 int bus_set_address_user(sd_bus *b) {
1227 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1229 return sd_bus_set_address(b, e);
1231 e = secure_getenv("XDG_RUNTIME_DIR");
1233 _cleanup_free_ char *ee = NULL;
1235 ee = bus_address_escape(e);
1239 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1241 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1249 _public_ int sd_bus_open_user(sd_bus **ret) {
1253 assert_return(ret, -EINVAL);
1259 r = bus_set_address_user(b);
1263 b->bus_client = true;
1266 /* We don't do any per-method access control on the user
1270 r = sd_bus_start(b);
1282 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1283 _cleanup_free_ char *e = NULL;
1284 char *m = NULL, *c = NULL;
1289 /* Let's see if we shall enter some container */
1290 m = strchr(host, ':');
1294 /* Let's make sure this is not a port of some kind,
1295 * and is a valid machine name. */
1296 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1299 /* Cut out the host part */
1300 t = strndupa(host, m - host - 1);
1301 e = bus_address_escape(t);
1305 c = strjoina(",argv4=--machine=", m);
1310 e = bus_address_escape(host);
1315 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1322 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1326 assert_return(host, -EINVAL);
1327 assert_return(ret, -EINVAL);
1329 r = sd_bus_new(&bus);
1333 r = bus_set_address_system_remote(bus, host);
1337 bus->bus_client = true;
1338 bus->trusted = false;
1339 bus->is_system = true;
1341 r = sd_bus_start(bus);
1353 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1354 _cleanup_free_ char *e = NULL;
1359 e = bus_address_escape(machine);
1363 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1370 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1374 assert_return(machine, -EINVAL);
1375 assert_return(ret, -EINVAL);
1376 assert_return(machine_name_is_valid(machine), -EINVAL);
1378 r = sd_bus_new(&bus);
1382 r = bus_set_address_system_machine(bus, machine);
1386 bus->bus_client = true;
1387 bus->trusted = false;
1388 bus->is_system = true;
1390 r = sd_bus_start(bus);
1402 _public_ void sd_bus_close(sd_bus *bus) {
1406 if (bus->state == BUS_CLOSED)
1408 if (bus_pid_changed(bus))
1411 bus->state = BUS_CLOSED;
1413 sd_bus_detach_event(bus);
1415 /* Drop all queued messages so that they drop references to
1416 * the bus object and the bus may be freed */
1417 bus_reset_queues(bus);
1419 if (!bus->is_kernel)
1422 /* We'll leave the fd open in case this is a kernel bus, since
1423 * there might still be memblocks around that reference this
1424 * bus, and they might need to invoke the KDBUS_CMD_FREE
1425 * ioctl on the fd when they are freed. */
1428 static void bus_enter_closing(sd_bus *bus) {
1431 if (bus->state != BUS_OPENING &&
1432 bus->state != BUS_AUTHENTICATING &&
1433 bus->state != BUS_HELLO &&
1434 bus->state != BUS_RUNNING)
1437 bus->state = BUS_CLOSING;
1440 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1441 assert_return(bus, NULL);
1443 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1448 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1454 i = REFCNT_DEC(bus->n_ref);
1462 _public_ int sd_bus_is_open(sd_bus *bus) {
1464 assert_return(bus, -EINVAL);
1465 assert_return(!bus_pid_changed(bus), -ECHILD);
1467 return BUS_IS_OPEN(bus->state);
1470 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1473 assert_return(bus, -EINVAL);
1474 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1475 assert_return(!bus_pid_changed(bus), -ECHILD);
1477 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1480 if (type == SD_BUS_TYPE_UNIX_FD) {
1481 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1484 r = bus_ensure_running(bus);
1488 return bus->can_fds;
1491 return bus_type_is_valid(type);
1494 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1497 assert_return(bus, -EINVAL);
1498 assert_return(id, -EINVAL);
1499 assert_return(!bus_pid_changed(bus), -ECHILD);
1501 r = bus_ensure_running(bus);
1505 *id = bus->server_id;
1509 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1514 /* If we copy the same message to multiple
1515 * destinations, avoid using the same cookie
1517 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1522 timeout = BUS_DEFAULT_TIMEOUT;
1524 return bus_message_seal(m, ++b->cookie, timeout);
1527 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1528 bool remarshal = false;
1532 /* wrong packet version */
1533 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1536 /* wrong packet endianness */
1537 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1540 /* TODO: kdbus-messages received from the kernel contain data which is
1541 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1542 * force remarshaling of the message. Technically, we could just
1543 * recreate the kdbus message, but that is non-trivial as other parts of
1544 * the message refer to m->kdbus already. This should be fixed! */
1545 if ((*m)->kdbus && (*m)->release_kdbus)
1548 return remarshal ? bus_message_remarshal(b, m) : 0;
1551 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1555 /* Fake some timestamps, if they were requested, and not
1556 * already initialized */
1557 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1558 if (m->realtime <= 0)
1559 m->realtime = now(CLOCK_REALTIME);
1561 if (m->monotonic <= 0)
1562 m->monotonic = now(CLOCK_MONOTONIC);
1565 /* The bus specification says the serial number cannot be 0,
1566 * hence let's fill something in for synthetic messages. Since
1567 * synthetic messages might have a fake sender and we don't
1568 * want to interfere with the real sender's serial numbers we
1569 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1570 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1571 * even though kdbus can do 64bit. */
1572 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1575 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1582 r = bus_kernel_write_message(bus, m, hint_sync_call);
1584 r = bus_socket_write_message(bus, m, idx);
1589 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1590 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1591 bus_message_type_to_string(m->header->type),
1592 strna(sd_bus_message_get_sender(m)),
1593 strna(sd_bus_message_get_destination(m)),
1594 strna(sd_bus_message_get_path(m)),
1595 strna(sd_bus_message_get_interface(m)),
1596 strna(sd_bus_message_get_member(m)),
1597 BUS_MESSAGE_COOKIE(m),
1599 strna(m->error.message));
1604 static int dispatch_wqueue(sd_bus *bus) {
1608 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1610 while (bus->wqueue_size > 0) {
1612 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1616 /* Didn't do anything this time */
1618 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1619 /* Fully written. Let's drop the entry from
1622 * This isn't particularly optimized, but
1623 * well, this is supposed to be our worst-case
1624 * buffer only, and the socket buffer is
1625 * supposed to be our primary buffer, and if
1626 * it got full, then all bets are off
1629 bus->wqueue_size --;
1630 sd_bus_message_unref(bus->wqueue[0]);
1631 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1641 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1645 return bus_kernel_read_message(bus, hint_priority, priority);
1647 return bus_socket_read_message(bus);
1650 int bus_rqueue_make_room(sd_bus *bus) {
1653 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1656 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1662 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1667 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1669 /* Note that the priority logic is only available on kdbus,
1670 * where the rqueue is unused. We check the rqueue here
1671 * anyway, because it's simple... */
1674 if (bus->rqueue_size > 0) {
1675 /* Dispatch a queued message */
1677 *m = bus->rqueue[0];
1678 bus->rqueue_size --;
1679 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1683 /* Try to read a new message */
1684 r = bus_read_message(bus, hint_priority, priority);
1694 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1695 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1698 assert_return(m, -EINVAL);
1703 assert_return(!bus_pid_changed(bus), -ECHILD);
1704 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1706 if (!BUS_IS_OPEN(bus->state))
1710 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1717 /* If the cookie number isn't kept, then we know that no reply
1719 if (!cookie && !m->sealed)
1720 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1722 r = bus_seal_message(bus, m, 0);
1726 /* Remarshall if we have to. This will possibly unref the
1727 * message and place a replacement in m */
1728 r = bus_remarshal_message(bus, &m);
1732 /* If this is a reply and no reply was requested, then let's
1733 * suppress this, if we can */
1737 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1740 r = bus_write_message(bus, m, hint_sync_call, &idx);
1742 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1743 bus_enter_closing(bus);
1750 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1751 /* Wasn't fully written. So let's remember how
1752 * much was written. Note that the first entry
1753 * of the wqueue array is always allocated so
1754 * that we always can remember how much was
1756 bus->wqueue[0] = sd_bus_message_ref(m);
1757 bus->wqueue_size = 1;
1762 /* Just append it to the queue. */
1764 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1767 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1770 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1775 *cookie = BUS_MESSAGE_COOKIE(m);
1780 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1781 return bus_send_internal(bus, m, cookie, false);
1784 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1787 assert_return(m, -EINVAL);
1792 assert_return(!bus_pid_changed(bus), -ECHILD);
1794 if (!BUS_IS_OPEN(bus->state))
1797 if (!streq_ptr(m->destination, destination)) {
1802 r = sd_bus_message_set_destination(m, destination);
1807 return sd_bus_send(bus, m, cookie);
1810 static usec_t calc_elapse(uint64_t usec) {
1811 if (usec == (uint64_t) -1)
1814 return now(CLOCK_MONOTONIC) + usec;
1817 static int timeout_compare(const void *a, const void *b) {
1818 const struct reply_callback *x = a, *y = b;
1820 if (x->timeout != 0 && y->timeout == 0)
1823 if (x->timeout == 0 && y->timeout != 0)
1826 if (x->timeout < y->timeout)
1829 if (x->timeout > y->timeout)
1835 _public_ int sd_bus_call_async(
1839 sd_bus_message_handler_t callback,
1843 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1844 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1847 assert_return(m, -EINVAL);
1848 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1849 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1850 assert_return(callback, -EINVAL);
1855 assert_return(!bus_pid_changed(bus), -ECHILD);
1856 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1858 if (!BUS_IS_OPEN(bus->state))
1861 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1865 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1869 r = bus_seal_message(bus, m, usec);
1873 r = bus_remarshal_message(bus, &m);
1877 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1881 s->reply_callback.callback = callback;
1883 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1884 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1886 s->reply_callback.cookie = 0;
1890 s->reply_callback.timeout = calc_elapse(m->timeout);
1891 if (s->reply_callback.timeout != 0) {
1892 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1894 s->reply_callback.timeout = 0;
1899 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1910 int bus_ensure_running(sd_bus *bus) {
1915 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1917 if (bus->state == BUS_RUNNING)
1921 r = sd_bus_process(bus, NULL);
1924 if (bus->state == BUS_RUNNING)
1929 r = sd_bus_wait(bus, (uint64_t) -1);
1935 _public_ int sd_bus_call(
1939 sd_bus_error *error,
1940 sd_bus_message **reply) {
1942 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1948 assert_return(m, -EINVAL);
1949 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1950 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1951 assert_return(!bus_error_is_dirty(error), -EINVAL);
1956 assert_return(!bus_pid_changed(bus), -ECHILD);
1957 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1959 if (!BUS_IS_OPEN(bus->state))
1962 r = bus_ensure_running(bus);
1966 i = bus->rqueue_size;
1968 r = bus_seal_message(bus, m, usec);
1972 r = bus_remarshal_message(bus, &m);
1976 r = bus_send_internal(bus, m, &cookie, true);
1980 timeout = calc_elapse(m->timeout);
1985 while (i < bus->rqueue_size) {
1986 sd_bus_message *incoming = NULL;
1988 incoming = bus->rqueue[i];
1990 if (incoming->reply_cookie == cookie) {
1991 /* Found a match! */
1993 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1995 log_debug_bus_message(incoming);
1997 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1999 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2003 sd_bus_message_unref(incoming);
2008 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2010 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
2011 r = sd_bus_error_copy(error, &incoming->error);
2015 sd_bus_message_unref(incoming);
2018 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2021 streq(bus->unique_name, incoming->sender)) {
2023 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2026 /* Our own message? Somebody is trying
2027 * to send its own client a message,
2028 * let's not dead-lock, let's fail
2031 sd_bus_message_unref(incoming);
2035 /* Try to read more, right-away */
2039 r = bus_read_message(bus, false, 0);
2041 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2042 bus_enter_closing(bus);
2054 n = now(CLOCK_MONOTONIC);
2060 left = (uint64_t) -1;
2062 r = bus_poll(bus, true, left);
2068 r = dispatch_wqueue(bus);
2070 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2071 bus_enter_closing(bus);
2080 _public_ int sd_bus_get_fd(sd_bus *bus) {
2082 assert_return(bus, -EINVAL);
2083 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2084 assert_return(!bus_pid_changed(bus), -ECHILD);
2086 return bus->input_fd;
2089 _public_ int sd_bus_get_events(sd_bus *bus) {
2092 assert_return(bus, -EINVAL);
2093 assert_return(!bus_pid_changed(bus), -ECHILD);
2095 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2098 if (bus->state == BUS_OPENING)
2100 else if (bus->state == BUS_AUTHENTICATING) {
2102 if (bus_socket_auth_needs_write(bus))
2107 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2108 if (bus->rqueue_size <= 0)
2110 if (bus->wqueue_size > 0)
2117 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2118 struct reply_callback *c;
2120 assert_return(bus, -EINVAL);
2121 assert_return(timeout_usec, -EINVAL);
2122 assert_return(!bus_pid_changed(bus), -ECHILD);
2124 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2127 if (bus->track_queue) {
2132 if (bus->state == BUS_CLOSING) {
2137 if (bus->state == BUS_AUTHENTICATING) {
2138 *timeout_usec = bus->auth_timeout;
2142 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2143 *timeout_usec = (uint64_t) -1;
2147 if (bus->rqueue_size > 0) {
2152 c = prioq_peek(bus->reply_callbacks_prioq);
2154 *timeout_usec = (uint64_t) -1;
2158 if (c->timeout == 0) {
2159 *timeout_usec = (uint64_t) -1;
2163 *timeout_usec = c->timeout;
2167 static int process_timeout(sd_bus *bus) {
2168 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2169 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2170 struct reply_callback *c;
2177 c = prioq_peek(bus->reply_callbacks_prioq);
2181 n = now(CLOCK_MONOTONIC);
2185 r = bus_message_new_synthetic_error(
2188 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2193 r = bus_seal_synthetic_message(bus, m);
2197 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2200 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2203 slot = container_of(c, sd_bus_slot, reply_callback);
2205 bus->iteration_counter ++;
2207 bus->current_message = m;
2208 bus->current_slot = sd_bus_slot_ref(slot);
2209 bus->current_handler = c->callback;
2210 bus->current_userdata = slot->userdata;
2211 r = c->callback(m, slot->userdata, &error_buffer);
2212 bus->current_userdata = NULL;
2213 bus->current_handler = NULL;
2214 bus->current_slot = NULL;
2215 bus->current_message = NULL;
2217 if (slot->floating) {
2218 bus_slot_disconnect(slot);
2219 sd_bus_slot_unref(slot);
2222 sd_bus_slot_unref(slot);
2224 return bus_maybe_reply_error(m, r, &error_buffer);
2227 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2231 if (bus->state != BUS_HELLO)
2234 /* Let's make sure the first message on the bus is the HELLO
2235 * reply. But note that we don't actually parse the message
2236 * here (we leave that to the usual handling), we just verify
2237 * we don't let any earlier msg through. */
2239 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2240 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2243 if (m->reply_cookie != 1)
2249 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2250 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2251 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2252 struct reply_callback *c;
2259 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2260 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2263 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2266 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2269 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2275 slot = container_of(c, sd_bus_slot, reply_callback);
2277 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2279 /* If the reply contained a file descriptor which we
2280 * didn't want we pass an error instead. */
2282 r = bus_message_new_synthetic_error(
2285 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2290 /* Copy over original timestamp */
2291 synthetic_reply->realtime = m->realtime;
2292 synthetic_reply->monotonic = m->monotonic;
2293 synthetic_reply->seqnum = m->seqnum;
2295 r = bus_seal_synthetic_message(bus, synthetic_reply);
2299 m = synthetic_reply;
2301 r = sd_bus_message_rewind(m, true);
2306 if (c->timeout != 0) {
2307 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2311 bus->current_slot = sd_bus_slot_ref(slot);
2312 bus->current_handler = c->callback;
2313 bus->current_userdata = slot->userdata;
2314 r = c->callback(m, slot->userdata, &error_buffer);
2315 bus->current_userdata = NULL;
2316 bus->current_handler = NULL;
2317 bus->current_slot = NULL;
2319 if (slot->floating) {
2320 bus_slot_disconnect(slot);
2321 sd_bus_slot_unref(slot);
2324 sd_bus_slot_unref(slot);
2326 return bus_maybe_reply_error(m, r, &error_buffer);
2329 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2330 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2331 struct filter_callback *l;
2338 bus->filter_callbacks_modified = false;
2340 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2343 if (bus->filter_callbacks_modified)
2346 /* Don't run this more than once per iteration */
2347 if (l->last_iteration == bus->iteration_counter)
2350 l->last_iteration = bus->iteration_counter;
2352 r = sd_bus_message_rewind(m, true);
2356 slot = container_of(l, sd_bus_slot, filter_callback);
2358 bus->current_slot = sd_bus_slot_ref(slot);
2359 bus->current_handler = l->callback;
2360 bus->current_userdata = slot->userdata;
2361 r = l->callback(m, slot->userdata, &error_buffer);
2362 bus->current_userdata = NULL;
2363 bus->current_handler = NULL;
2364 bus->current_slot = sd_bus_slot_unref(slot);
2366 r = bus_maybe_reply_error(m, r, &error_buffer);
2372 } while (bus->filter_callbacks_modified);
2377 static int process_match(sd_bus *bus, sd_bus_message *m) {
2384 bus->match_callbacks_modified = false;
2386 r = bus_match_run(bus, &bus->match_callbacks, m);
2390 } while (bus->match_callbacks_modified);
2395 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2396 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2402 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2405 if (bus->manual_peer_interface)
2408 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2411 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2414 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2417 if (streq_ptr(m->member, "Ping"))
2418 r = sd_bus_message_new_method_return(m, &reply);
2419 else if (streq_ptr(m->member, "GetMachineId")) {
2423 r = sd_id128_get_machine(&id);
2427 r = sd_bus_message_new_method_return(m, &reply);
2431 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2433 r = sd_bus_message_new_method_errorf(
2435 SD_BUS_ERROR_UNKNOWN_METHOD,
2436 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2442 r = sd_bus_send(bus, reply, NULL);
2449 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2453 /* If we got a message with a file descriptor which we didn't
2454 * want to accept, then let's drop it. How can this even
2455 * happen? For example, when the kernel queues a message into
2456 * an activatable names's queue which allows fds, and then is
2457 * delivered to us later even though we ourselves did not
2460 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2466 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2469 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2470 return 1; /* just eat it up */
2472 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2475 static int process_message(sd_bus *bus, sd_bus_message *m) {
2481 bus->current_message = m;
2482 bus->iteration_counter++;
2484 log_debug_bus_message(m);
2486 r = process_hello(bus, m);
2490 r = process_reply(bus, m);
2494 r = process_fd_check(bus, m);
2498 r = process_filter(bus, m);
2502 r = process_match(bus, m);
2506 r = process_builtin(bus, m);
2510 r = bus_process_object(bus, m);
2513 bus->current_message = NULL;
2517 static int dispatch_track(sd_bus *bus) {
2520 if (!bus->track_queue)
2523 bus_track_dispatch(bus->track_queue);
2527 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2528 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2532 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2534 r = process_timeout(bus);
2538 r = dispatch_wqueue(bus);
2542 r = dispatch_track(bus);
2546 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2552 r = process_message(bus, m);
2557 r = sd_bus_message_rewind(m, true);
2566 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2568 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2569 strna(sd_bus_message_get_sender(m)),
2570 strna(sd_bus_message_get_path(m)),
2571 strna(sd_bus_message_get_interface(m)),
2572 strna(sd_bus_message_get_member(m)));
2574 r = sd_bus_reply_method_errorf(
2576 SD_BUS_ERROR_UNKNOWN_OBJECT,
2577 "Unknown object '%s'.", m->path);
2591 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2592 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2593 struct reply_callback *c;
2597 assert(bus->state == BUS_CLOSING);
2599 c = ordered_hashmap_first(bus->reply_callbacks);
2601 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2604 /* First, fail all outstanding method calls */
2605 r = bus_message_new_synthetic_error(
2608 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2613 r = bus_seal_synthetic_message(bus, m);
2617 if (c->timeout != 0) {
2618 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2622 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2625 slot = container_of(c, sd_bus_slot, reply_callback);
2627 bus->iteration_counter++;
2629 bus->current_message = m;
2630 bus->current_slot = sd_bus_slot_ref(slot);
2631 bus->current_handler = c->callback;
2632 bus->current_userdata = slot->userdata;
2633 r = c->callback(m, slot->userdata, &error_buffer);
2634 bus->current_userdata = NULL;
2635 bus->current_handler = NULL;
2636 bus->current_slot = NULL;
2637 bus->current_message = NULL;
2639 if (slot->floating) {
2640 bus_slot_disconnect(slot);
2641 sd_bus_slot_unref(slot);
2644 sd_bus_slot_unref(slot);
2646 return bus_maybe_reply_error(m, r, &error_buffer);
2649 /* Then, synthesize a Disconnected message */
2650 r = sd_bus_message_new_signal(
2653 "/org/freedesktop/DBus/Local",
2654 "org.freedesktop.DBus.Local",
2659 bus_message_set_sender_local(bus, m);
2661 r = bus_seal_synthetic_message(bus, m);
2667 bus->current_message = m;
2668 bus->iteration_counter++;
2670 r = process_filter(bus, m);
2674 r = process_match(bus, m);
2686 bus->current_message = NULL;
2691 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2692 BUS_DONT_DESTROY(bus);
2695 /* Returns 0 when we didn't do anything. This should cause the
2696 * caller to invoke sd_bus_wait() before returning the next
2697 * time. Returns > 0 when we did something, which possibly
2698 * means *ret is filled in with an unprocessed message. */
2700 assert_return(bus, -EINVAL);
2701 assert_return(!bus_pid_changed(bus), -ECHILD);
2703 /* We don't allow recursively invoking sd_bus_process(). */
2704 assert_return(!bus->current_message, -EBUSY);
2705 assert(!bus->current_slot);
2707 switch (bus->state) {
2716 r = bus_socket_process_opening(bus);
2717 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2718 bus_enter_closing(bus);
2726 case BUS_AUTHENTICATING:
2727 r = bus_socket_process_authenticating(bus);
2728 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2729 bus_enter_closing(bus);
2741 r = process_running(bus, hint_priority, priority, ret);
2742 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2743 bus_enter_closing(bus);
2753 return process_closing(bus, ret);
2756 assert_not_reached("Unknown state");
2759 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2760 return bus_process_internal(bus, false, 0, ret);
2763 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2764 return bus_process_internal(bus, true, priority, ret);
2767 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2768 struct pollfd p[2] = {};
2771 usec_t m = USEC_INFINITY;
2775 if (bus->state == BUS_CLOSING)
2778 if (!BUS_IS_OPEN(bus->state))
2781 e = sd_bus_get_events(bus);
2786 /* The caller really needs some more data, he doesn't
2787 * care about what's already read, or any timeouts
2788 * except its own. */
2792 /* The caller wants to process if there's something to
2793 * process, but doesn't care otherwise */
2795 r = sd_bus_get_timeout(bus, &until);
2800 nw = now(CLOCK_MONOTONIC);
2801 m = until > nw ? until - nw : 0;
2805 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2808 p[0].fd = bus->input_fd;
2809 if (bus->output_fd == bus->input_fd) {
2813 p[0].events = e & POLLIN;
2814 p[1].fd = bus->output_fd;
2815 p[1].events = e & POLLOUT;
2819 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2823 return r > 0 ? 1 : 0;
2826 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2828 assert_return(bus, -EINVAL);
2829 assert_return(!bus_pid_changed(bus), -ECHILD);
2831 if (bus->state == BUS_CLOSING)
2834 if (!BUS_IS_OPEN(bus->state))
2837 if (bus->rqueue_size > 0)
2840 return bus_poll(bus, false, timeout_usec);
2843 _public_ int sd_bus_flush(sd_bus *bus) {
2846 assert_return(bus, -EINVAL);
2847 assert_return(!bus_pid_changed(bus), -ECHILD);
2849 if (bus->state == BUS_CLOSING)
2852 if (!BUS_IS_OPEN(bus->state))
2855 r = bus_ensure_running(bus);
2859 if (bus->wqueue_size <= 0)
2863 r = dispatch_wqueue(bus);
2865 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2866 bus_enter_closing(bus);
2873 if (bus->wqueue_size <= 0)
2876 r = bus_poll(bus, false, (uint64_t) -1);
2882 _public_ int sd_bus_add_filter(
2885 sd_bus_message_handler_t callback,
2890 assert_return(bus, -EINVAL);
2891 assert_return(callback, -EINVAL);
2892 assert_return(!bus_pid_changed(bus), -ECHILD);
2894 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2898 s->filter_callback.callback = callback;
2900 bus->filter_callbacks_modified = true;
2901 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2909 _public_ int sd_bus_add_match(
2913 sd_bus_message_handler_t callback,
2916 struct bus_match_component *components = NULL;
2917 unsigned n_components = 0;
2918 sd_bus_slot *s = NULL;
2921 assert_return(bus, -EINVAL);
2922 assert_return(match, -EINVAL);
2923 assert_return(!bus_pid_changed(bus), -ECHILD);
2925 r = bus_match_parse(match, &components, &n_components);
2929 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2935 s->match_callback.callback = callback;
2936 s->match_callback.cookie = ++bus->match_cookie;
2938 if (bus->bus_client) {
2939 enum bus_match_scope scope;
2941 scope = bus_match_get_scope(components, n_components);
2943 /* Do not install server-side matches for matches
2944 * against the local service, interface or bus
2946 if (scope != BUS_MATCH_LOCAL) {
2948 if (!bus->is_kernel) {
2949 /* When this is not a kernel transport, we
2950 * store the original match string, so that we
2951 * can use it to remove the match again */
2953 s->match_callback.match_string = strdup(match);
2954 if (!s->match_callback.match_string) {
2960 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2964 s->match_added = true;
2968 bus->match_callbacks_modified = true;
2969 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2978 bus_match_parse_free(components, n_components);
2979 sd_bus_slot_unref(s);
2984 int bus_remove_match_by_string(
2987 sd_bus_message_handler_t callback,
2990 struct bus_match_component *components = NULL;
2991 unsigned n_components = 0;
2992 struct match_callback *c;
2995 assert_return(bus, -EINVAL);
2996 assert_return(match, -EINVAL);
2997 assert_return(!bus_pid_changed(bus), -ECHILD);
2999 r = bus_match_parse(match, &components, &n_components);
3003 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3007 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3010 bus_match_parse_free(components, n_components);
3015 bool bus_pid_changed(sd_bus *bus) {
3018 /* We don't support people creating a bus connection and
3019 * keeping it around over a fork(). Let's complain. */
3021 return bus->original_pid != getpid();
3024 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3025 sd_bus *bus = userdata;
3030 r = sd_bus_process(bus, NULL);
3037 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3038 sd_bus *bus = userdata;
3043 r = sd_bus_process(bus, NULL);
3050 static int prepare_callback(sd_event_source *s, void *userdata) {
3051 sd_bus *bus = userdata;
3058 e = sd_bus_get_events(bus);
3062 if (bus->output_fd != bus->input_fd) {
3064 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3068 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3072 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3077 r = sd_bus_get_timeout(bus, &until);
3083 j = sd_event_source_set_time(bus->time_event_source, until);
3088 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3095 static int quit_callback(sd_event_source *event, void *userdata) {
3096 sd_bus *bus = userdata;
3106 static int attach_io_events(sd_bus *bus) {
3111 if (bus->input_fd < 0)
3117 if (!bus->input_io_event_source) {
3118 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3122 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3126 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3130 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3132 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3137 if (bus->output_fd != bus->input_fd) {
3138 assert(bus->output_fd >= 0);
3140 if (!bus->output_io_event_source) {
3141 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3145 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3149 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3151 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3160 static void detach_io_events(sd_bus *bus) {
3163 if (bus->input_io_event_source) {
3164 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3165 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3168 if (bus->output_io_event_source) {
3169 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3170 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3174 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3177 assert_return(bus, -EINVAL);
3178 assert_return(!bus->event, -EBUSY);
3180 assert(!bus->input_io_event_source);
3181 assert(!bus->output_io_event_source);
3182 assert(!bus->time_event_source);
3185 bus->event = sd_event_ref(event);
3187 r = sd_event_default(&bus->event);
3192 bus->event_priority = priority;
3194 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3198 r = sd_event_source_set_priority(bus->time_event_source, priority);
3202 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3206 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3210 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3214 r = attach_io_events(bus);
3221 sd_bus_detach_event(bus);
3225 _public_ int sd_bus_detach_event(sd_bus *bus) {
3226 assert_return(bus, -EINVAL);
3231 detach_io_events(bus);
3233 if (bus->time_event_source) {
3234 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3235 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3238 if (bus->quit_event_source) {
3239 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3240 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3243 bus->event = sd_event_unref(bus->event);
3247 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3248 assert_return(bus, NULL);
3253 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3254 assert_return(bus, NULL);
3256 return bus->current_message;
3259 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3260 assert_return(bus, NULL);
3262 return bus->current_slot;
3265 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3266 assert_return(bus, NULL);
3268 return bus->current_handler;
3271 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3272 assert_return(bus, NULL);
3274 return bus->current_userdata;
3277 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3282 assert(default_bus);
3285 return !!*default_bus;
3288 *ret = sd_bus_ref(*default_bus);
3296 b->default_bus_ptr = default_bus;
3304 _public_ int sd_bus_default_system(sd_bus **ret) {
3305 static thread_local sd_bus *default_system_bus = NULL;
3307 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3310 _public_ int sd_bus_default_user(sd_bus **ret) {
3311 static thread_local sd_bus *default_user_bus = NULL;
3313 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3316 _public_ int sd_bus_default(sd_bus **ret) {
3320 /* Let's try our best to reuse another cached connection. If
3321 * the starter bus type is set, connect via our normal
3322 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3323 * we can share the connection with the user/system default
3326 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3328 if (streq(e, "system"))
3329 return sd_bus_default_system(ret);
3330 else if (STR_IN_SET(e, "user", "session"))
3331 return sd_bus_default_user(ret);
3334 /* No type is specified, so we have not other option than to
3335 * use the starter address if it is set. */
3337 e = secure_getenv("DBUS_STARTER_ADDRESS");
3339 static thread_local sd_bus *default_starter_bus = NULL;
3341 return bus_default(sd_bus_open, &default_starter_bus, ret);
3344 /* Finally, if nothing is set use the cached connection for
3345 * the right scope */
3347 return sd_bus_default_system(ret);
3350 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3351 assert_return(b, -EINVAL);
3352 assert_return(tid, -EINVAL);
3353 assert_return(!bus_pid_changed(b), -ECHILD);
3361 return sd_event_get_tid(b->event, tid);
3366 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3367 _cleanup_free_ char *e = NULL;
3370 assert_return(object_path_is_valid(prefix), -EINVAL);
3371 assert_return(external_id, -EINVAL);
3372 assert_return(ret_path, -EINVAL);
3374 e = bus_label_escape(external_id);
3378 ret = strjoin(prefix, "/", e, NULL);
3386 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3390 assert_return(object_path_is_valid(path), -EINVAL);
3391 assert_return(object_path_is_valid(prefix), -EINVAL);
3392 assert_return(external_id, -EINVAL);
3394 e = object_path_startswith(path, prefix);
3396 *external_id = NULL;
3400 ret = bus_label_unescape(e);
3408 _public_ int sd_bus_try_close(sd_bus *bus) {
3411 assert_return(bus, -EINVAL);
3412 assert_return(!bus_pid_changed(bus), -ECHILD);
3414 if (!bus->is_kernel)
3417 if (!BUS_IS_OPEN(bus->state))
3420 if (bus->rqueue_size > 0)
3423 if (bus->wqueue_size > 0)
3426 r = bus_kernel_try_close(bus);
3434 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3435 assert_return(bus, -EINVAL);
3436 assert_return(description, -EINVAL);
3437 assert_return(bus->description, -ENXIO);
3438 assert_return(!bus_pid_changed(bus), -ECHILD);
3440 *description = bus->description;
3444 int bus_get_root_path(sd_bus *bus) {
3447 if (bus->cgroup_root)
3450 r = cg_get_root_path(&bus->cgroup_root);
3452 bus->cgroup_root = strdup("/");
3453 if (!bus->cgroup_root)
3462 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3465 assert_return(bus, -EINVAL);
3466 assert_return(scope, -EINVAL);
3467 assert_return(!bus_pid_changed(bus), -ECHILD);
3469 if (bus->is_kernel) {
3470 _cleanup_free_ char *n = NULL;
3473 r = bus_kernel_get_bus_name(bus, &n);
3477 if (streq(n, "0-system")) {
3482 dash = strchr(n, '-');
3483 if (streq_ptr(dash, "-user")) {
3494 if (bus->is_system) {
3502 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3504 assert_return(bus, -EINVAL);
3505 assert_return(address, -EINVAL);
3506 assert_return(!bus_pid_changed(bus), -ECHILD);
3509 *address = bus->address;
3516 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3517 assert_return(bus, -EINVAL);
3518 assert_return(mask, -EINVAL);
3519 assert_return(!bus_pid_changed(bus), -ECHILD);
3521 *mask = bus->creds_mask;
3525 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3526 assert_return(bus, -EINVAL);
3527 assert_return(!bus_pid_changed(bus), -ECHILD);
3529 return bus->bus_client;
3532 _public_ int sd_bus_is_server(sd_bus *bus) {
3533 assert_return(bus, -EINVAL);
3534 assert_return(!bus_pid_changed(bus), -ECHILD);
3536 return bus->is_server;
3539 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3540 assert_return(bus, -EINVAL);
3541 assert_return(!bus_pid_changed(bus), -ECHILD);
3543 return bus->anonymous_auth;
3546 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3547 assert_return(bus, -EINVAL);
3548 assert_return(!bus_pid_changed(bus), -ECHILD);
3550 return bus->trusted;
3553 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3554 assert_return(bus, -EINVAL);
3555 assert_return(!bus_pid_changed(bus), -ECHILD);
3557 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);