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 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1436 return sd_bus_unref(bus);
1439 static void bus_enter_closing(sd_bus *bus) {
1442 if (bus->state != BUS_OPENING &&
1443 bus->state != BUS_AUTHENTICATING &&
1444 bus->state != BUS_HELLO &&
1445 bus->state != BUS_RUNNING)
1448 bus->state = BUS_CLOSING;
1451 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1452 assert_return(bus, NULL);
1454 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1459 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1465 i = REFCNT_DEC(bus->n_ref);
1473 _public_ int sd_bus_is_open(sd_bus *bus) {
1475 assert_return(bus, -EINVAL);
1476 assert_return(!bus_pid_changed(bus), -ECHILD);
1478 return BUS_IS_OPEN(bus->state);
1481 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1484 assert_return(bus, -EINVAL);
1485 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1486 assert_return(!bus_pid_changed(bus), -ECHILD);
1488 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1491 if (type == SD_BUS_TYPE_UNIX_FD) {
1492 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1495 r = bus_ensure_running(bus);
1499 return bus->can_fds;
1502 return bus_type_is_valid(type);
1505 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1508 assert_return(bus, -EINVAL);
1509 assert_return(id, -EINVAL);
1510 assert_return(!bus_pid_changed(bus), -ECHILD);
1512 r = bus_ensure_running(bus);
1516 *id = bus->server_id;
1520 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1525 /* If we copy the same message to multiple
1526 * destinations, avoid using the same cookie
1528 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1533 timeout = BUS_DEFAULT_TIMEOUT;
1535 return bus_message_seal(m, ++b->cookie, timeout);
1538 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1539 bool remarshal = false;
1543 /* wrong packet version */
1544 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1547 /* wrong packet endianness */
1548 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1551 /* TODO: kdbus-messages received from the kernel contain data which is
1552 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1553 * force remarshaling of the message. Technically, we could just
1554 * recreate the kdbus message, but that is non-trivial as other parts of
1555 * the message refer to m->kdbus already. This should be fixed! */
1556 if ((*m)->kdbus && (*m)->release_kdbus)
1559 return remarshal ? bus_message_remarshal(b, m) : 0;
1562 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1566 /* Fake some timestamps, if they were requested, and not
1567 * already initialized */
1568 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1569 if (m->realtime <= 0)
1570 m->realtime = now(CLOCK_REALTIME);
1572 if (m->monotonic <= 0)
1573 m->monotonic = now(CLOCK_MONOTONIC);
1576 /* The bus specification says the serial number cannot be 0,
1577 * hence let's fill something in for synthetic messages. Since
1578 * synthetic messages might have a fake sender and we don't
1579 * want to interfere with the real sender's serial numbers we
1580 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1581 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1582 * even though kdbus can do 64bit. */
1583 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1586 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1593 r = bus_kernel_write_message(bus, m, hint_sync_call);
1595 r = bus_socket_write_message(bus, m, idx);
1600 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1601 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1602 bus_message_type_to_string(m->header->type),
1603 strna(sd_bus_message_get_sender(m)),
1604 strna(sd_bus_message_get_destination(m)),
1605 strna(sd_bus_message_get_path(m)),
1606 strna(sd_bus_message_get_interface(m)),
1607 strna(sd_bus_message_get_member(m)),
1608 BUS_MESSAGE_COOKIE(m),
1610 strna(m->error.message));
1615 static int dispatch_wqueue(sd_bus *bus) {
1619 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1621 while (bus->wqueue_size > 0) {
1623 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1627 /* Didn't do anything this time */
1629 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1630 /* Fully written. Let's drop the entry from
1633 * This isn't particularly optimized, but
1634 * well, this is supposed to be our worst-case
1635 * buffer only, and the socket buffer is
1636 * supposed to be our primary buffer, and if
1637 * it got full, then all bets are off
1640 bus->wqueue_size --;
1641 sd_bus_message_unref(bus->wqueue[0]);
1642 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1652 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1656 return bus_kernel_read_message(bus, hint_priority, priority);
1658 return bus_socket_read_message(bus);
1661 int bus_rqueue_make_room(sd_bus *bus) {
1664 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1667 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1673 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1678 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1680 /* Note that the priority logic is only available on kdbus,
1681 * where the rqueue is unused. We check the rqueue here
1682 * anyway, because it's simple... */
1685 if (bus->rqueue_size > 0) {
1686 /* Dispatch a queued message */
1688 *m = bus->rqueue[0];
1689 bus->rqueue_size --;
1690 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1694 /* Try to read a new message */
1695 r = bus_read_message(bus, hint_priority, priority);
1705 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1706 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1709 assert_return(m, -EINVAL);
1714 assert_return(!bus_pid_changed(bus), -ECHILD);
1715 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1717 if (!BUS_IS_OPEN(bus->state))
1721 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1728 /* If the cookie number isn't kept, then we know that no reply
1730 if (!cookie && !m->sealed)
1731 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1733 r = bus_seal_message(bus, m, 0);
1737 /* Remarshall if we have to. This will possibly unref the
1738 * message and place a replacement in m */
1739 r = bus_remarshal_message(bus, &m);
1743 /* If this is a reply and no reply was requested, then let's
1744 * suppress this, if we can */
1748 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1751 r = bus_write_message(bus, m, hint_sync_call, &idx);
1753 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1754 bus_enter_closing(bus);
1761 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1762 /* Wasn't fully written. So let's remember how
1763 * much was written. Note that the first entry
1764 * of the wqueue array is always allocated so
1765 * that we always can remember how much was
1767 bus->wqueue[0] = sd_bus_message_ref(m);
1768 bus->wqueue_size = 1;
1773 /* Just append it to the queue. */
1775 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1778 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1781 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1786 *cookie = BUS_MESSAGE_COOKIE(m);
1791 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1792 return bus_send_internal(bus, m, cookie, false);
1795 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1798 assert_return(m, -EINVAL);
1803 assert_return(!bus_pid_changed(bus), -ECHILD);
1805 if (!BUS_IS_OPEN(bus->state))
1808 if (!streq_ptr(m->destination, destination)) {
1813 r = sd_bus_message_set_destination(m, destination);
1818 return sd_bus_send(bus, m, cookie);
1821 static usec_t calc_elapse(uint64_t usec) {
1822 if (usec == (uint64_t) -1)
1825 return now(CLOCK_MONOTONIC) + usec;
1828 static int timeout_compare(const void *a, const void *b) {
1829 const struct reply_callback *x = a, *y = b;
1831 if (x->timeout != 0 && y->timeout == 0)
1834 if (x->timeout == 0 && y->timeout != 0)
1837 if (x->timeout < y->timeout)
1840 if (x->timeout > y->timeout)
1846 _public_ int sd_bus_call_async(
1850 sd_bus_message_handler_t callback,
1854 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1855 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1858 assert_return(m, -EINVAL);
1859 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1860 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1861 assert_return(callback, -EINVAL);
1866 assert_return(!bus_pid_changed(bus), -ECHILD);
1867 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1869 if (!BUS_IS_OPEN(bus->state))
1872 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1876 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1880 r = bus_seal_message(bus, m, usec);
1884 r = bus_remarshal_message(bus, &m);
1888 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1892 s->reply_callback.callback = callback;
1894 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1895 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1897 s->reply_callback.cookie = 0;
1901 s->reply_callback.timeout = calc_elapse(m->timeout);
1902 if (s->reply_callback.timeout != 0) {
1903 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1905 s->reply_callback.timeout = 0;
1910 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1921 int bus_ensure_running(sd_bus *bus) {
1926 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1928 if (bus->state == BUS_RUNNING)
1932 r = sd_bus_process(bus, NULL);
1935 if (bus->state == BUS_RUNNING)
1940 r = sd_bus_wait(bus, (uint64_t) -1);
1946 _public_ int sd_bus_call(
1950 sd_bus_error *error,
1951 sd_bus_message **reply) {
1953 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1959 assert_return(m, -EINVAL);
1960 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1961 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1962 assert_return(!bus_error_is_dirty(error), -EINVAL);
1967 assert_return(!bus_pid_changed(bus), -ECHILD);
1968 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1970 if (!BUS_IS_OPEN(bus->state))
1973 r = bus_ensure_running(bus);
1977 i = bus->rqueue_size;
1979 r = bus_seal_message(bus, m, usec);
1983 r = bus_remarshal_message(bus, &m);
1987 r = bus_send_internal(bus, m, &cookie, true);
1991 timeout = calc_elapse(m->timeout);
1996 while (i < bus->rqueue_size) {
1997 sd_bus_message *incoming = NULL;
1999 incoming = bus->rqueue[i];
2001 if (incoming->reply_cookie == cookie) {
2002 /* Found a match! */
2004 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2006 log_debug_bus_message(incoming);
2008 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2010 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2014 sd_bus_message_unref(incoming);
2019 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2021 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
2022 r = sd_bus_error_copy(error, &incoming->error);
2026 sd_bus_message_unref(incoming);
2029 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2032 streq(bus->unique_name, incoming->sender)) {
2034 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2037 /* Our own message? Somebody is trying
2038 * to send its own client a message,
2039 * let's not dead-lock, let's fail
2042 sd_bus_message_unref(incoming);
2046 /* Try to read more, right-away */
2050 r = bus_read_message(bus, false, 0);
2052 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2053 bus_enter_closing(bus);
2065 n = now(CLOCK_MONOTONIC);
2071 left = (uint64_t) -1;
2073 r = bus_poll(bus, true, left);
2079 r = dispatch_wqueue(bus);
2081 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2082 bus_enter_closing(bus);
2091 _public_ int sd_bus_get_fd(sd_bus *bus) {
2093 assert_return(bus, -EINVAL);
2094 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2095 assert_return(!bus_pid_changed(bus), -ECHILD);
2097 return bus->input_fd;
2100 _public_ int sd_bus_get_events(sd_bus *bus) {
2103 assert_return(bus, -EINVAL);
2104 assert_return(!bus_pid_changed(bus), -ECHILD);
2106 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2109 if (bus->state == BUS_OPENING)
2111 else if (bus->state == BUS_AUTHENTICATING) {
2113 if (bus_socket_auth_needs_write(bus))
2118 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2119 if (bus->rqueue_size <= 0)
2121 if (bus->wqueue_size > 0)
2128 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2129 struct reply_callback *c;
2131 assert_return(bus, -EINVAL);
2132 assert_return(timeout_usec, -EINVAL);
2133 assert_return(!bus_pid_changed(bus), -ECHILD);
2135 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2138 if (bus->track_queue) {
2143 if (bus->state == BUS_CLOSING) {
2148 if (bus->state == BUS_AUTHENTICATING) {
2149 *timeout_usec = bus->auth_timeout;
2153 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2154 *timeout_usec = (uint64_t) -1;
2158 if (bus->rqueue_size > 0) {
2163 c = prioq_peek(bus->reply_callbacks_prioq);
2165 *timeout_usec = (uint64_t) -1;
2169 if (c->timeout == 0) {
2170 *timeout_usec = (uint64_t) -1;
2174 *timeout_usec = c->timeout;
2178 static int process_timeout(sd_bus *bus) {
2179 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2180 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2181 struct reply_callback *c;
2188 c = prioq_peek(bus->reply_callbacks_prioq);
2192 n = now(CLOCK_MONOTONIC);
2196 r = bus_message_new_synthetic_error(
2199 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2204 r = bus_seal_synthetic_message(bus, m);
2208 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2211 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2214 slot = container_of(c, sd_bus_slot, reply_callback);
2216 bus->iteration_counter ++;
2218 bus->current_message = m;
2219 bus->current_slot = sd_bus_slot_ref(slot);
2220 bus->current_handler = c->callback;
2221 bus->current_userdata = slot->userdata;
2222 r = c->callback(m, slot->userdata, &error_buffer);
2223 bus->current_userdata = NULL;
2224 bus->current_handler = NULL;
2225 bus->current_slot = NULL;
2226 bus->current_message = NULL;
2228 if (slot->floating) {
2229 bus_slot_disconnect(slot);
2230 sd_bus_slot_unref(slot);
2233 sd_bus_slot_unref(slot);
2235 return bus_maybe_reply_error(m, r, &error_buffer);
2238 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2242 if (bus->state != BUS_HELLO)
2245 /* Let's make sure the first message on the bus is the HELLO
2246 * reply. But note that we don't actually parse the message
2247 * here (we leave that to the usual handling), we just verify
2248 * we don't let any earlier msg through. */
2250 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2251 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2254 if (m->reply_cookie != 1)
2260 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2261 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2262 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2263 struct reply_callback *c;
2270 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2271 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2274 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2277 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2280 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2286 slot = container_of(c, sd_bus_slot, reply_callback);
2288 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2290 /* If the reply contained a file descriptor which we
2291 * didn't want we pass an error instead. */
2293 r = bus_message_new_synthetic_error(
2296 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2301 /* Copy over original timestamp */
2302 synthetic_reply->realtime = m->realtime;
2303 synthetic_reply->monotonic = m->monotonic;
2304 synthetic_reply->seqnum = m->seqnum;
2306 r = bus_seal_synthetic_message(bus, synthetic_reply);
2310 m = synthetic_reply;
2312 r = sd_bus_message_rewind(m, true);
2317 if (c->timeout != 0) {
2318 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2322 bus->current_slot = sd_bus_slot_ref(slot);
2323 bus->current_handler = c->callback;
2324 bus->current_userdata = slot->userdata;
2325 r = c->callback(m, slot->userdata, &error_buffer);
2326 bus->current_userdata = NULL;
2327 bus->current_handler = NULL;
2328 bus->current_slot = NULL;
2330 if (slot->floating) {
2331 bus_slot_disconnect(slot);
2332 sd_bus_slot_unref(slot);
2335 sd_bus_slot_unref(slot);
2337 return bus_maybe_reply_error(m, r, &error_buffer);
2340 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2341 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2342 struct filter_callback *l;
2349 bus->filter_callbacks_modified = false;
2351 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2354 if (bus->filter_callbacks_modified)
2357 /* Don't run this more than once per iteration */
2358 if (l->last_iteration == bus->iteration_counter)
2361 l->last_iteration = bus->iteration_counter;
2363 r = sd_bus_message_rewind(m, true);
2367 slot = container_of(l, sd_bus_slot, filter_callback);
2369 bus->current_slot = sd_bus_slot_ref(slot);
2370 bus->current_handler = l->callback;
2371 bus->current_userdata = slot->userdata;
2372 r = l->callback(m, slot->userdata, &error_buffer);
2373 bus->current_userdata = NULL;
2374 bus->current_handler = NULL;
2375 bus->current_slot = sd_bus_slot_unref(slot);
2377 r = bus_maybe_reply_error(m, r, &error_buffer);
2383 } while (bus->filter_callbacks_modified);
2388 static int process_match(sd_bus *bus, sd_bus_message *m) {
2395 bus->match_callbacks_modified = false;
2397 r = bus_match_run(bus, &bus->match_callbacks, m);
2401 } while (bus->match_callbacks_modified);
2406 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2407 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2413 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2416 if (bus->manual_peer_interface)
2419 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2422 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2425 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2428 if (streq_ptr(m->member, "Ping"))
2429 r = sd_bus_message_new_method_return(m, &reply);
2430 else if (streq_ptr(m->member, "GetMachineId")) {
2434 r = sd_id128_get_machine(&id);
2438 r = sd_bus_message_new_method_return(m, &reply);
2442 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2444 r = sd_bus_message_new_method_errorf(
2446 SD_BUS_ERROR_UNKNOWN_METHOD,
2447 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2453 r = sd_bus_send(bus, reply, NULL);
2460 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2464 /* If we got a message with a file descriptor which we didn't
2465 * want to accept, then let's drop it. How can this even
2466 * happen? For example, when the kernel queues a message into
2467 * an activatable names's queue which allows fds, and then is
2468 * delivered to us later even though we ourselves did not
2471 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2477 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2480 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2481 return 1; /* just eat it up */
2483 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2486 static int process_message(sd_bus *bus, sd_bus_message *m) {
2492 bus->current_message = m;
2493 bus->iteration_counter++;
2495 log_debug_bus_message(m);
2497 r = process_hello(bus, m);
2501 r = process_reply(bus, m);
2505 r = process_fd_check(bus, m);
2509 r = process_filter(bus, m);
2513 r = process_match(bus, m);
2517 r = process_builtin(bus, m);
2521 r = bus_process_object(bus, m);
2524 bus->current_message = NULL;
2528 static int dispatch_track(sd_bus *bus) {
2531 if (!bus->track_queue)
2534 bus_track_dispatch(bus->track_queue);
2538 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2539 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2543 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2545 r = process_timeout(bus);
2549 r = dispatch_wqueue(bus);
2553 r = dispatch_track(bus);
2557 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2563 r = process_message(bus, m);
2568 r = sd_bus_message_rewind(m, true);
2577 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2579 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2580 strna(sd_bus_message_get_sender(m)),
2581 strna(sd_bus_message_get_path(m)),
2582 strna(sd_bus_message_get_interface(m)),
2583 strna(sd_bus_message_get_member(m)));
2585 r = sd_bus_reply_method_errorf(
2587 SD_BUS_ERROR_UNKNOWN_OBJECT,
2588 "Unknown object '%s'.", m->path);
2602 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2603 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2604 struct reply_callback *c;
2608 assert(bus->state == BUS_CLOSING);
2610 c = ordered_hashmap_first(bus->reply_callbacks);
2612 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2615 /* First, fail all outstanding method calls */
2616 r = bus_message_new_synthetic_error(
2619 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2624 r = bus_seal_synthetic_message(bus, m);
2628 if (c->timeout != 0) {
2629 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2633 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2636 slot = container_of(c, sd_bus_slot, reply_callback);
2638 bus->iteration_counter++;
2640 bus->current_message = m;
2641 bus->current_slot = sd_bus_slot_ref(slot);
2642 bus->current_handler = c->callback;
2643 bus->current_userdata = slot->userdata;
2644 r = c->callback(m, slot->userdata, &error_buffer);
2645 bus->current_userdata = NULL;
2646 bus->current_handler = NULL;
2647 bus->current_slot = NULL;
2648 bus->current_message = NULL;
2650 if (slot->floating) {
2651 bus_slot_disconnect(slot);
2652 sd_bus_slot_unref(slot);
2655 sd_bus_slot_unref(slot);
2657 return bus_maybe_reply_error(m, r, &error_buffer);
2660 /* Then, synthesize a Disconnected message */
2661 r = sd_bus_message_new_signal(
2664 "/org/freedesktop/DBus/Local",
2665 "org.freedesktop.DBus.Local",
2670 bus_message_set_sender_local(bus, m);
2672 r = bus_seal_synthetic_message(bus, m);
2678 bus->current_message = m;
2679 bus->iteration_counter++;
2681 r = process_filter(bus, m);
2685 r = process_match(bus, m);
2697 bus->current_message = NULL;
2702 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2703 BUS_DONT_DESTROY(bus);
2706 /* Returns 0 when we didn't do anything. This should cause the
2707 * caller to invoke sd_bus_wait() before returning the next
2708 * time. Returns > 0 when we did something, which possibly
2709 * means *ret is filled in with an unprocessed message. */
2711 assert_return(bus, -EINVAL);
2712 assert_return(!bus_pid_changed(bus), -ECHILD);
2714 /* We don't allow recursively invoking sd_bus_process(). */
2715 assert_return(!bus->current_message, -EBUSY);
2716 assert(!bus->current_slot);
2718 switch (bus->state) {
2727 r = bus_socket_process_opening(bus);
2728 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2729 bus_enter_closing(bus);
2737 case BUS_AUTHENTICATING:
2738 r = bus_socket_process_authenticating(bus);
2739 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2740 bus_enter_closing(bus);
2752 r = process_running(bus, hint_priority, priority, ret);
2753 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2754 bus_enter_closing(bus);
2764 return process_closing(bus, ret);
2767 assert_not_reached("Unknown state");
2770 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2771 return bus_process_internal(bus, false, 0, ret);
2774 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2775 return bus_process_internal(bus, true, priority, ret);
2778 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2779 struct pollfd p[2] = {};
2782 usec_t m = USEC_INFINITY;
2786 if (bus->state == BUS_CLOSING)
2789 if (!BUS_IS_OPEN(bus->state))
2792 e = sd_bus_get_events(bus);
2797 /* The caller really needs some more data, he doesn't
2798 * care about what's already read, or any timeouts
2799 * except its own. */
2803 /* The caller wants to process if there's something to
2804 * process, but doesn't care otherwise */
2806 r = sd_bus_get_timeout(bus, &until);
2811 nw = now(CLOCK_MONOTONIC);
2812 m = until > nw ? until - nw : 0;
2816 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2819 p[0].fd = bus->input_fd;
2820 if (bus->output_fd == bus->input_fd) {
2824 p[0].events = e & POLLIN;
2825 p[1].fd = bus->output_fd;
2826 p[1].events = e & POLLOUT;
2830 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2834 return r > 0 ? 1 : 0;
2837 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2839 assert_return(bus, -EINVAL);
2840 assert_return(!bus_pid_changed(bus), -ECHILD);
2842 if (bus->state == BUS_CLOSING)
2845 if (!BUS_IS_OPEN(bus->state))
2848 if (bus->rqueue_size > 0)
2851 return bus_poll(bus, false, timeout_usec);
2854 _public_ int sd_bus_flush(sd_bus *bus) {
2857 assert_return(bus, -EINVAL);
2858 assert_return(!bus_pid_changed(bus), -ECHILD);
2860 if (bus->state == BUS_CLOSING)
2863 if (!BUS_IS_OPEN(bus->state))
2866 r = bus_ensure_running(bus);
2870 if (bus->wqueue_size <= 0)
2874 r = dispatch_wqueue(bus);
2876 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2877 bus_enter_closing(bus);
2884 if (bus->wqueue_size <= 0)
2887 r = bus_poll(bus, false, (uint64_t) -1);
2893 _public_ int sd_bus_add_filter(
2896 sd_bus_message_handler_t callback,
2901 assert_return(bus, -EINVAL);
2902 assert_return(callback, -EINVAL);
2903 assert_return(!bus_pid_changed(bus), -ECHILD);
2905 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2909 s->filter_callback.callback = callback;
2911 bus->filter_callbacks_modified = true;
2912 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2920 _public_ int sd_bus_add_match(
2924 sd_bus_message_handler_t callback,
2927 struct bus_match_component *components = NULL;
2928 unsigned n_components = 0;
2929 sd_bus_slot *s = NULL;
2932 assert_return(bus, -EINVAL);
2933 assert_return(match, -EINVAL);
2934 assert_return(!bus_pid_changed(bus), -ECHILD);
2936 r = bus_match_parse(match, &components, &n_components);
2940 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2946 s->match_callback.callback = callback;
2947 s->match_callback.cookie = ++bus->match_cookie;
2949 if (bus->bus_client) {
2950 enum bus_match_scope scope;
2952 scope = bus_match_get_scope(components, n_components);
2954 /* Do not install server-side matches for matches
2955 * against the local service, interface or bus
2957 if (scope != BUS_MATCH_LOCAL) {
2959 if (!bus->is_kernel) {
2960 /* When this is not a kernel transport, we
2961 * store the original match string, so that we
2962 * can use it to remove the match again */
2964 s->match_callback.match_string = strdup(match);
2965 if (!s->match_callback.match_string) {
2971 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2975 s->match_added = true;
2979 bus->match_callbacks_modified = true;
2980 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2989 bus_match_parse_free(components, n_components);
2990 sd_bus_slot_unref(s);
2995 int bus_remove_match_by_string(
2998 sd_bus_message_handler_t callback,
3001 struct bus_match_component *components = NULL;
3002 unsigned n_components = 0;
3003 struct match_callback *c;
3006 assert_return(bus, -EINVAL);
3007 assert_return(match, -EINVAL);
3008 assert_return(!bus_pid_changed(bus), -ECHILD);
3010 r = bus_match_parse(match, &components, &n_components);
3014 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3018 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3021 bus_match_parse_free(components, n_components);
3026 bool bus_pid_changed(sd_bus *bus) {
3029 /* We don't support people creating a bus connection and
3030 * keeping it around over a fork(). Let's complain. */
3032 return bus->original_pid != getpid();
3035 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3036 sd_bus *bus = userdata;
3041 r = sd_bus_process(bus, NULL);
3048 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3049 sd_bus *bus = userdata;
3054 r = sd_bus_process(bus, NULL);
3061 static int prepare_callback(sd_event_source *s, void *userdata) {
3062 sd_bus *bus = userdata;
3069 e = sd_bus_get_events(bus);
3073 if (bus->output_fd != bus->input_fd) {
3075 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3079 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3083 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3088 r = sd_bus_get_timeout(bus, &until);
3094 j = sd_event_source_set_time(bus->time_event_source, until);
3099 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3106 static int quit_callback(sd_event_source *event, void *userdata) {
3107 sd_bus *bus = userdata;
3117 static int attach_io_events(sd_bus *bus) {
3122 if (bus->input_fd < 0)
3128 if (!bus->input_io_event_source) {
3129 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3133 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3137 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3141 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3143 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3148 if (bus->output_fd != bus->input_fd) {
3149 assert(bus->output_fd >= 0);
3151 if (!bus->output_io_event_source) {
3152 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3156 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3160 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3162 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3171 static void detach_io_events(sd_bus *bus) {
3174 if (bus->input_io_event_source) {
3175 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3176 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3179 if (bus->output_io_event_source) {
3180 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3181 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3185 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3188 assert_return(bus, -EINVAL);
3189 assert_return(!bus->event, -EBUSY);
3191 assert(!bus->input_io_event_source);
3192 assert(!bus->output_io_event_source);
3193 assert(!bus->time_event_source);
3196 bus->event = sd_event_ref(event);
3198 r = sd_event_default(&bus->event);
3203 bus->event_priority = priority;
3205 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3209 r = sd_event_source_set_priority(bus->time_event_source, priority);
3213 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3217 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3221 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3225 r = attach_io_events(bus);
3232 sd_bus_detach_event(bus);
3236 _public_ int sd_bus_detach_event(sd_bus *bus) {
3237 assert_return(bus, -EINVAL);
3242 detach_io_events(bus);
3244 if (bus->time_event_source) {
3245 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3246 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3249 if (bus->quit_event_source) {
3250 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3251 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3254 bus->event = sd_event_unref(bus->event);
3258 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3259 assert_return(bus, NULL);
3264 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3265 assert_return(bus, NULL);
3267 return bus->current_message;
3270 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3271 assert_return(bus, NULL);
3273 return bus->current_slot;
3276 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3277 assert_return(bus, NULL);
3279 return bus->current_handler;
3282 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3283 assert_return(bus, NULL);
3285 return bus->current_userdata;
3288 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3293 assert(default_bus);
3296 return !!*default_bus;
3299 *ret = sd_bus_ref(*default_bus);
3307 b->default_bus_ptr = default_bus;
3315 _public_ int sd_bus_default_system(sd_bus **ret) {
3316 static thread_local sd_bus *default_system_bus = NULL;
3318 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3321 _public_ int sd_bus_default_user(sd_bus **ret) {
3322 static thread_local sd_bus *default_user_bus = NULL;
3324 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3327 _public_ int sd_bus_default(sd_bus **ret) {
3331 /* Let's try our best to reuse another cached connection. If
3332 * the starter bus type is set, connect via our normal
3333 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3334 * we can share the connection with the user/system default
3337 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3339 if (streq(e, "system"))
3340 return sd_bus_default_system(ret);
3341 else if (STR_IN_SET(e, "user", "session"))
3342 return sd_bus_default_user(ret);
3345 /* No type is specified, so we have not other option than to
3346 * use the starter address if it is set. */
3348 e = secure_getenv("DBUS_STARTER_ADDRESS");
3350 static thread_local sd_bus *default_starter_bus = NULL;
3352 return bus_default(sd_bus_open, &default_starter_bus, ret);
3355 /* Finally, if nothing is set use the cached connection for
3356 * the right scope */
3358 return sd_bus_default_system(ret);
3361 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3362 assert_return(b, -EINVAL);
3363 assert_return(tid, -EINVAL);
3364 assert_return(!bus_pid_changed(b), -ECHILD);
3372 return sd_event_get_tid(b->event, tid);
3377 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3378 _cleanup_free_ char *e = NULL;
3381 assert_return(object_path_is_valid(prefix), -EINVAL);
3382 assert_return(external_id, -EINVAL);
3383 assert_return(ret_path, -EINVAL);
3385 e = bus_label_escape(external_id);
3389 ret = strjoin(prefix, "/", e, NULL);
3397 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3401 assert_return(object_path_is_valid(path), -EINVAL);
3402 assert_return(object_path_is_valid(prefix), -EINVAL);
3403 assert_return(external_id, -EINVAL);
3405 e = object_path_startswith(path, prefix);
3407 *external_id = NULL;
3411 ret = bus_label_unescape(e);
3419 _public_ int sd_bus_try_close(sd_bus *bus) {
3422 assert_return(bus, -EINVAL);
3423 assert_return(!bus_pid_changed(bus), -ECHILD);
3425 if (!bus->is_kernel)
3428 if (!BUS_IS_OPEN(bus->state))
3431 if (bus->rqueue_size > 0)
3434 if (bus->wqueue_size > 0)
3437 r = bus_kernel_try_close(bus);
3445 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3446 assert_return(bus, -EINVAL);
3447 assert_return(description, -EINVAL);
3448 assert_return(bus->description, -ENXIO);
3449 assert_return(!bus_pid_changed(bus), -ECHILD);
3451 *description = bus->description;
3455 int bus_get_root_path(sd_bus *bus) {
3458 if (bus->cgroup_root)
3461 r = cg_get_root_path(&bus->cgroup_root);
3463 bus->cgroup_root = strdup("/");
3464 if (!bus->cgroup_root)
3473 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3476 assert_return(bus, -EINVAL);
3477 assert_return(scope, -EINVAL);
3478 assert_return(!bus_pid_changed(bus), -ECHILD);
3480 if (bus->is_kernel) {
3481 _cleanup_free_ char *n = NULL;
3484 r = bus_kernel_get_bus_name(bus, &n);
3488 if (streq(n, "0-system")) {
3493 dash = strchr(n, '-');
3494 if (streq_ptr(dash, "-user")) {
3505 if (bus->is_system) {
3513 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3515 assert_return(bus, -EINVAL);
3516 assert_return(address, -EINVAL);
3517 assert_return(!bus_pid_changed(bus), -ECHILD);
3520 *address = bus->address;
3527 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3528 assert_return(bus, -EINVAL);
3529 assert_return(mask, -EINVAL);
3530 assert_return(!bus_pid_changed(bus), -ECHILD);
3532 *mask = bus->creds_mask;
3536 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3537 assert_return(bus, -EINVAL);
3538 assert_return(!bus_pid_changed(bus), -ECHILD);
3540 return bus->bus_client;
3543 _public_ int sd_bus_is_server(sd_bus *bus) {
3544 assert_return(bus, -EINVAL);
3545 assert_return(!bus_pid_changed(bus), -ECHILD);
3547 return bus->is_server;
3550 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3551 assert_return(bus, -EINVAL);
3552 assert_return(!bus_pid_changed(bus), -ECHILD);
3554 return bus->anonymous_auth;
3557 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3558 assert_return(bus, -EINVAL);
3559 assert_return(!bus_pid_changed(bus), -ECHILD);
3561 return bus->trusted;
3564 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3565 assert_return(bus, -EINVAL);
3566 assert_return(!bus_pid_changed(bus), -ECHILD);
3568 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);