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) {
76 if (b->input_fd != b->output_fd)
77 safe_close(b->output_fd);
78 b->output_fd = b->input_fd = safe_close(b->input_fd);
81 static void bus_reset_queues(sd_bus *b) {
84 while (b->rqueue_size > 0)
85 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
87 b->rqueue = mfree(b->rqueue);
88 b->rqueue_allocated = 0;
90 while (b->wqueue_size > 0)
91 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
93 b->wqueue = mfree(b->wqueue);
94 b->wqueue_allocated = 0;
97 static void bus_free(sd_bus *b) {
101 assert(!b->track_queue);
103 b->state = BUS_CLOSED;
105 sd_bus_detach_event(b);
107 while ((s = b->slots)) {
108 /* At this point only floating slots can still be
109 * around, because the non-floating ones keep a
110 * reference to the bus, and we thus couldn't be
111 * destructing right now... We forcibly disconnect the
112 * slots here, so that they still can be referenced by
113 * apps, but are dead. */
116 bus_slot_disconnect(s);
117 sd_bus_slot_unref(s);
120 if (b->default_bus_ptr)
121 *b->default_bus_ptr = NULL;
126 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
130 free(b->unique_name);
131 free(b->auth_buffer);
136 free(b->cgroup_root);
137 free(b->description);
140 strv_free(b->exec_argv);
142 close_many(b->fds, b->n_fds);
147 ordered_hashmap_free_free(b->reply_callbacks);
148 prioq_free(b->reply_callbacks_prioq);
150 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
151 bus_match_free(&b->match_callbacks);
153 hashmap_free_free(b->vtable_methods);
154 hashmap_free_free(b->vtable_properties);
156 assert(hashmap_isempty(b->nodes));
157 hashmap_free(b->nodes);
159 bus_kernel_flush_memfd(b);
161 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
166 _public_ int sd_bus_new(sd_bus **ret) {
169 assert_return(ret, -EINVAL);
175 r->n_ref = REFCNT_INIT;
176 r->input_fd = r->output_fd = -1;
177 r->message_version = 1;
178 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
179 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
180 r->attach_flags |= KDBUS_ATTACH_NAMES;
181 r->original_pid = getpid();
183 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
185 /* We guarantee that wqueue always has space for at least one
187 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
196 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
199 assert_return(bus, -EINVAL);
200 assert_return(bus->state == BUS_UNSET, -EPERM);
201 assert_return(address, -EINVAL);
202 assert_return(!bus_pid_changed(bus), -ECHILD);
214 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
215 assert_return(bus, -EINVAL);
216 assert_return(bus->state == BUS_UNSET, -EPERM);
217 assert_return(input_fd >= 0, -EINVAL);
218 assert_return(output_fd >= 0, -EINVAL);
219 assert_return(!bus_pid_changed(bus), -ECHILD);
221 bus->input_fd = input_fd;
222 bus->output_fd = output_fd;
226 /// UNNEEDED by elogind
228 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
231 assert_return(bus, -EINVAL);
232 assert_return(bus->state == BUS_UNSET, -EPERM);
233 assert_return(path, -EINVAL);
234 assert_return(!strv_isempty(argv), -EINVAL);
235 assert_return(!bus_pid_changed(bus), -ECHILD);
247 free(bus->exec_path);
248 strv_free(bus->exec_argv);
256 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
257 assert_return(bus, -EINVAL);
258 assert_return(bus->state == BUS_UNSET, -EPERM);
259 assert_return(!bus_pid_changed(bus), -ECHILD);
261 bus->bus_client = !!b;
265 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
266 assert_return(bus, -EINVAL);
267 assert_return(bus->state == BUS_UNSET, -EPERM);
268 assert_return(!bus_pid_changed(bus), -ECHILD);
270 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
274 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
275 assert_return(bus, -EINVAL);
276 assert_return(bus->state == BUS_UNSET, -EPERM);
277 assert_return(!bus_pid_changed(bus), -ECHILD);
279 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
283 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
285 assert_return(bus, -EINVAL);
286 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
287 assert_return(!bus_pid_changed(bus), -ECHILD);
289 new_flags = bus->attach_flags;
290 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
292 if (bus->attach_flags == new_flags)
295 bus->attach_flags = new_flags;
296 if (bus->state != BUS_UNSET && bus->is_kernel)
297 bus_kernel_realize_attach_flags(bus);
303 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
306 assert_return(bus, -EINVAL);
307 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
308 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
309 assert_return(!bus_pid_changed(bus), -ECHILD);
312 bus->creds_mask |= mask;
314 bus->creds_mask &= ~mask;
316 /* The well knowns we need unconditionally, so that matches can work */
317 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
319 /* Make sure we don't lose the timestamp flag */
320 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
321 if (bus->attach_flags == new_flags)
324 bus->attach_flags = new_flags;
325 if (bus->state != BUS_UNSET && bus->is_kernel)
326 bus_kernel_realize_attach_flags(bus);
331 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
332 assert_return(bus, -EINVAL);
333 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
334 assert_return(bus->state == BUS_UNSET, -EPERM);
335 assert_return(!bus_pid_changed(bus), -ECHILD);
337 bus->is_server = !!b;
338 bus->server_id = server_id;
342 /// UNNEEDED by elogind
344 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
345 assert_return(bus, -EINVAL);
346 assert_return(bus->state == BUS_UNSET, -EPERM);
347 assert_return(!bus_pid_changed(bus), -ECHILD);
349 bus->anonymous_auth = !!b;
353 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
354 assert_return(bus, -EINVAL);
355 assert_return(bus->state == BUS_UNSET, -EPERM);
356 assert_return(!bus_pid_changed(bus), -ECHILD);
362 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
363 assert_return(bus, -EINVAL);
364 assert_return(bus->state == BUS_UNSET, -EPERM);
365 assert_return(!bus_pid_changed(bus), -ECHILD);
367 return free_and_strdup(&bus->description, description);
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 /// UNNEEDED by elogind
381 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
382 assert_return(bus, -EINVAL);
383 assert_return(!bus_pid_changed(bus), -ECHILD);
385 return bus->allow_interactive_authorization;
389 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
397 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
399 r = sd_bus_message_get_errno(reply);
403 r = sd_bus_message_read(reply, "s", &s);
407 if (!service_name_is_valid(s) || s[0] != ':')
410 bus->unique_name = strdup(s);
411 if (!bus->unique_name)
414 if (bus->state == BUS_HELLO)
415 bus->state = BUS_RUNNING;
420 static int bus_send_hello(sd_bus *bus) {
421 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
426 if (!bus->bus_client || bus->is_kernel)
429 r = sd_bus_message_new_method_call(
432 "org.freedesktop.DBus",
433 "/org/freedesktop/DBus",
434 "org.freedesktop.DBus",
439 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
442 int bus_start_running(sd_bus *bus) {
445 if (bus->bus_client && !bus->is_kernel) {
446 bus->state = BUS_HELLO;
450 bus->state = BUS_RUNNING;
454 static int parse_address_key(const char **p, const char *key, char **value) {
455 size_t l, n = 0, allocated = 0;
465 if (strncmp(*p, key, l) != 0)
478 while (*a != ';' && *a != ',' && *a != 0) {
496 c = (char) ((x << 4) | y);
503 if (!GREEDY_REALLOC(r, allocated, n + 2))
527 static void skip_address_key(const char **p) {
531 *p += strcspn(*p, ",");
537 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
538 _cleanup_free_ char *path = NULL, *abstract = NULL;
547 while (**p != 0 && **p != ';') {
548 r = parse_address_key(p, "guid", guid);
554 r = parse_address_key(p, "path", &path);
560 r = parse_address_key(p, "abstract", &abstract);
569 if (!path && !abstract)
572 if (path && abstract)
577 if (l > sizeof(b->sockaddr.un.sun_path))
580 b->sockaddr.un.sun_family = AF_UNIX;
581 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
582 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
583 } else if (abstract) {
584 l = strlen(abstract);
585 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
588 b->sockaddr.un.sun_family = AF_UNIX;
589 b->sockaddr.un.sun_path[0] = 0;
590 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
591 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
597 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
598 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
600 struct addrinfo *result, hints = {
601 .ai_socktype = SOCK_STREAM,
602 .ai_flags = AI_ADDRCONFIG,
610 while (**p != 0 && **p != ';') {
611 r = parse_address_key(p, "guid", guid);
617 r = parse_address_key(p, "host", &host);
623 r = parse_address_key(p, "port", &port);
629 r = parse_address_key(p, "family", &family);
642 if (streq(family, "ipv4"))
643 hints.ai_family = AF_INET;
644 else if (streq(family, "ipv6"))
645 hints.ai_family = AF_INET6;
650 r = getaddrinfo(host, port, &hints, &result);
654 return -EADDRNOTAVAIL;
656 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
657 b->sockaddr_size = result->ai_addrlen;
659 freeaddrinfo(result);
664 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
666 unsigned n_argv = 0, j;
668 size_t allocated = 0;
676 while (**p != 0 && **p != ';') {
677 r = parse_address_key(p, "guid", guid);
683 r = parse_address_key(p, "path", &path);
689 if (startswith(*p, "argv")) {
693 ul = strtoul(*p + 4, (char**) p, 10);
694 if (errno > 0 || **p != '=' || ul > 256) {
702 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
710 r = parse_address_key(p, NULL, argv + ul);
725 /* Make sure there are no holes in the array, with the
726 * exception of argv[0] */
727 for (j = 1; j < n_argv; j++)
733 if (argv && argv[0] == NULL) {
734 argv[0] = strdup(path);
746 for (j = 0; j < n_argv; j++)
754 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
755 _cleanup_free_ char *path = NULL;
763 while (**p != 0 && **p != ';') {
764 r = parse_address_key(p, "guid", guid);
770 r = parse_address_key(p, "path", &path);
789 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
790 _cleanup_free_ char *machine = NULL, *pid = NULL;
798 while (**p != 0 && **p != ';') {
799 r = parse_address_key(p, "guid", guid);
805 r = parse_address_key(p, "machine", &machine);
811 r = parse_address_key(p, "pid", &pid);
820 if (!machine == !pid)
824 if (!machine_name_is_valid(machine))
828 b->machine = machine;
836 r = parse_pid(pid, &b->nspid);
842 b->sockaddr.un.sun_family = AF_UNIX;
843 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
844 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
849 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
850 _cleanup_free_ char *machine = NULL, *pid = NULL;
858 while (**p != 0 && **p != ';') {
859 r = parse_address_key(p, "guid", guid);
865 r = parse_address_key(p, "machine", &machine);
871 r = parse_address_key(p, "pid", &pid);
880 if (!machine == !pid)
884 if (!machine_name_is_valid(machine))
888 b->machine = machine;
896 r = parse_pid(pid, &b->nspid);
903 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
910 static void bus_reset_parsed_address(sd_bus *b) {
914 b->sockaddr_size = 0;
915 strv_free(b->exec_argv);
919 b->server_id = SD_ID128_NULL;
927 static int bus_parse_next_address(sd_bus *b) {
928 _cleanup_free_ char *guid = NULL;
936 if (b->address[b->address_index] == 0)
939 bus_reset_parsed_address(b);
941 a = b->address + b->address_index;
950 if (startswith(a, "unix:")) {
953 r = parse_unix_address(b, &a, &guid);
958 } else if (startswith(a, "tcp:")) {
961 r = parse_tcp_address(b, &a, &guid);
967 } else if (startswith(a, "unixexec:")) {
970 r = parse_exec_address(b, &a, &guid);
976 } else if (startswith(a, "kernel:")) {
979 r = parse_kernel_address(b, &a, &guid);
984 } else if (startswith(a, "x-machine-unix:")) {
987 r = parse_container_unix_address(b, &a, &guid);
992 } else if (startswith(a, "x-machine-kernel:")) {
995 r = parse_container_kernel_address(b, &a, &guid);
1008 r = sd_id128_from_string(guid, &b->server_id);
1013 b->address_index = a - b->address;
1017 static int bus_start_address(sd_bus *b) {
1023 bool skipped = false;
1028 r = bus_socket_exec(b);
1030 else if ((b->nspid > 0 || b->machine) && b->kernel)
1031 r = bus_container_connect_kernel(b);
1032 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1033 r = bus_container_connect_socket(b);
1036 r = bus_kernel_connect(b);
1037 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1038 r = bus_socket_connect(b);
1044 r = attach_io_events(b);
1049 b->last_connect_error = -r;
1052 r = bus_parse_next_address(b);
1056 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1060 int bus_next_address(sd_bus *b) {
1063 bus_reset_parsed_address(b);
1064 return bus_start_address(b);
1067 static int bus_start_fd(sd_bus *b) {
1072 assert(b->input_fd >= 0);
1073 assert(b->output_fd >= 0);
1075 r = fd_nonblock(b->input_fd, true);
1079 r = fd_cloexec(b->input_fd, true);
1083 if (b->input_fd != b->output_fd) {
1084 r = fd_nonblock(b->output_fd, true);
1088 r = fd_cloexec(b->output_fd, true);
1093 if (fstat(b->input_fd, &st) < 0)
1096 if (S_ISCHR(b->input_fd))
1097 return bus_kernel_take_fd(b);
1099 return bus_socket_take_fd(b);
1102 _public_ int sd_bus_start(sd_bus *bus) {
1105 assert_return(bus, -EINVAL);
1106 assert_return(bus->state == BUS_UNSET, -EPERM);
1107 assert_return(!bus_pid_changed(bus), -ECHILD);
1109 bus->state = BUS_OPENING;
1111 if (bus->is_server && bus->bus_client)
1114 if (bus->input_fd >= 0)
1115 r = bus_start_fd(bus);
1116 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1117 r = bus_start_address(bus);
1126 return bus_send_hello(bus);
1129 _public_ int sd_bus_open(sd_bus **ret) {
1134 assert_return(ret, -EINVAL);
1136 /* Let's connect to the starter bus if it is set, and
1137 * otherwise to the bus that is appropropriate for the scope
1138 * we are running in */
1140 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1142 if (streq(e, "system"))
1143 return sd_bus_open_system(ret);
1144 else if (STR_IN_SET(e, "session", "user"))
1145 return sd_bus_open_user(ret);
1148 e = secure_getenv("DBUS_STARTER_ADDRESS");
1150 return sd_bus_open_system(ret);
1157 r = sd_bus_set_address(b, e);
1161 b->bus_client = true;
1163 /* We don't know whether the bus is trusted or not, so better
1164 * be safe, and authenticate everything */
1166 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1167 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1169 r = sd_bus_start(b);
1181 int bus_set_address_system(sd_bus *b) {
1185 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1187 return sd_bus_set_address(b, e);
1189 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1192 _public_ int sd_bus_open_system(sd_bus **ret) {
1196 assert_return(ret, -EINVAL);
1202 r = bus_set_address_system(b);
1206 b->bus_client = true;
1207 b->is_system = true;
1209 /* Let's do per-method access control on the system bus. We
1210 * need the caller's UID and capability set for that. */
1212 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1213 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1215 r = sd_bus_start(b);
1227 int bus_set_address_user(sd_bus *b) {
1232 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1234 return sd_bus_set_address(b, e);
1236 e = secure_getenv("XDG_RUNTIME_DIR");
1238 _cleanup_free_ char *ee = NULL;
1240 ee = bus_address_escape(e);
1244 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1246 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1254 _public_ int sd_bus_open_user(sd_bus **ret) {
1258 assert_return(ret, -EINVAL);
1264 r = bus_set_address_user(b);
1268 b->bus_client = true;
1271 /* We don't do any per-method access control on the user
1275 r = sd_bus_start(b);
1287 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1288 _cleanup_free_ char *e = NULL;
1289 char *m = NULL, *c = NULL;
1294 /* Let's see if we shall enter some container */
1295 m = strchr(host, ':');
1299 /* Let's make sure this is not a port of some kind,
1300 * and is a valid machine name. */
1301 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1304 /* Cut out the host part */
1305 t = strndupa(host, m - host - 1);
1306 e = bus_address_escape(t);
1310 c = strjoina(",argv4=--machine=", m);
1315 e = bus_address_escape(host);
1320 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1327 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1331 assert_return(host, -EINVAL);
1332 assert_return(ret, -EINVAL);
1334 r = sd_bus_new(&bus);
1338 r = bus_set_address_system_remote(bus, host);
1342 bus->bus_client = true;
1343 bus->trusted = false;
1344 bus->is_system = true;
1346 r = sd_bus_start(bus);
1358 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1359 _cleanup_free_ char *e = NULL;
1364 e = bus_address_escape(machine);
1368 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1375 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1379 assert_return(machine, -EINVAL);
1380 assert_return(ret, -EINVAL);
1381 assert_return(machine_name_is_valid(machine), -EINVAL);
1383 r = sd_bus_new(&bus);
1387 r = bus_set_address_system_machine(bus, machine);
1391 bus->bus_client = true;
1392 bus->trusted = false;
1393 bus->is_system = true;
1395 r = sd_bus_start(bus);
1407 _public_ void sd_bus_close(sd_bus *bus) {
1411 if (bus->state == BUS_CLOSED)
1413 if (bus_pid_changed(bus))
1416 bus->state = BUS_CLOSED;
1418 sd_bus_detach_event(bus);
1420 /* Drop all queued messages so that they drop references to
1421 * the bus object and the bus may be freed */
1422 bus_reset_queues(bus);
1424 if (!bus->is_kernel)
1427 /* We'll leave the fd open in case this is a kernel bus, since
1428 * there might still be memblocks around that reference this
1429 * bus, and they might need to invoke the KDBUS_CMD_FREE
1430 * ioctl on the fd when they are freed. */
1433 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1441 return sd_bus_unref(bus);
1444 static void bus_enter_closing(sd_bus *bus) {
1447 if (bus->state != BUS_OPENING &&
1448 bus->state != BUS_AUTHENTICATING &&
1449 bus->state != BUS_HELLO &&
1450 bus->state != BUS_RUNNING)
1453 bus->state = BUS_CLOSING;
1456 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1457 assert_return(bus, NULL);
1459 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1464 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1470 i = REFCNT_DEC(bus->n_ref);
1478 /// UNNEEDED by elogind
1480 _public_ int sd_bus_is_open(sd_bus *bus) {
1482 assert_return(bus, -EINVAL);
1483 assert_return(!bus_pid_changed(bus), -ECHILD);
1485 return BUS_IS_OPEN(bus->state);
1489 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1492 assert_return(bus, -EINVAL);
1493 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1494 assert_return(!bus_pid_changed(bus), -ECHILD);
1496 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1499 if (type == SD_BUS_TYPE_UNIX_FD) {
1500 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1503 r = bus_ensure_running(bus);
1507 return bus->can_fds;
1510 return bus_type_is_valid(type);
1513 /// UNNEEDED by elogind
1515 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1518 assert_return(bus, -EINVAL);
1519 assert_return(id, -EINVAL);
1520 assert_return(!bus_pid_changed(bus), -ECHILD);
1522 r = bus_ensure_running(bus);
1526 *id = bus->server_id;
1531 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1536 /* If we copy the same message to multiple
1537 * destinations, avoid using the same cookie
1539 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1544 timeout = BUS_DEFAULT_TIMEOUT;
1546 return bus_message_seal(m, ++b->cookie, timeout);
1549 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1550 bool remarshal = false;
1554 /* wrong packet version */
1555 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1558 /* wrong packet endianness */
1559 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1562 /* TODO: kdbus-messages received from the kernel contain data which is
1563 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1564 * force remarshaling of the message. Technically, we could just
1565 * recreate the kdbus message, but that is non-trivial as other parts of
1566 * the message refer to m->kdbus already. This should be fixed! */
1567 if ((*m)->kdbus && (*m)->release_kdbus)
1570 return remarshal ? bus_message_remarshal(b, m) : 0;
1573 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1577 /* Fake some timestamps, if they were requested, and not
1578 * already initialized */
1579 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1580 if (m->realtime <= 0)
1581 m->realtime = now(CLOCK_REALTIME);
1583 if (m->monotonic <= 0)
1584 m->monotonic = now(CLOCK_MONOTONIC);
1587 /* The bus specification says the serial number cannot be 0,
1588 * hence let's fill something in for synthetic messages. Since
1589 * synthetic messages might have a fake sender and we don't
1590 * want to interfere with the real sender's serial numbers we
1591 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1592 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1593 * even though kdbus can do 64bit. */
1594 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1597 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1604 r = bus_kernel_write_message(bus, m, hint_sync_call);
1606 r = bus_socket_write_message(bus, m, idx);
1611 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1612 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1613 bus_message_type_to_string(m->header->type),
1614 strna(sd_bus_message_get_sender(m)),
1615 strna(sd_bus_message_get_destination(m)),
1616 strna(sd_bus_message_get_path(m)),
1617 strna(sd_bus_message_get_interface(m)),
1618 strna(sd_bus_message_get_member(m)),
1619 BUS_MESSAGE_COOKIE(m),
1621 strna(m->error.message));
1626 static int dispatch_wqueue(sd_bus *bus) {
1630 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1632 while (bus->wqueue_size > 0) {
1634 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1638 /* Didn't do anything this time */
1640 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1641 /* Fully written. Let's drop the entry from
1644 * This isn't particularly optimized, but
1645 * well, this is supposed to be our worst-case
1646 * buffer only, and the socket buffer is
1647 * supposed to be our primary buffer, and if
1648 * it got full, then all bets are off
1651 bus->wqueue_size --;
1652 sd_bus_message_unref(bus->wqueue[0]);
1653 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1663 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1667 return bus_kernel_read_message(bus, hint_priority, priority);
1669 return bus_socket_read_message(bus);
1672 int bus_rqueue_make_room(sd_bus *bus) {
1675 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1678 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1684 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1689 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1691 /* Note that the priority logic is only available on kdbus,
1692 * where the rqueue is unused. We check the rqueue here
1693 * anyway, because it's simple... */
1696 if (bus->rqueue_size > 0) {
1697 /* Dispatch a queued message */
1699 *m = bus->rqueue[0];
1700 bus->rqueue_size --;
1701 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1705 /* Try to read a new message */
1706 r = bus_read_message(bus, hint_priority, priority);
1716 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1717 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1720 assert_return(m, -EINVAL);
1725 assert_return(!bus_pid_changed(bus), -ECHILD);
1726 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1728 if (!BUS_IS_OPEN(bus->state))
1732 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1739 /* If the cookie number isn't kept, then we know that no reply
1741 if (!cookie && !m->sealed)
1742 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1744 r = bus_seal_message(bus, m, 0);
1748 /* Remarshall if we have to. This will possibly unref the
1749 * message and place a replacement in m */
1750 r = bus_remarshal_message(bus, &m);
1754 /* If this is a reply and no reply was requested, then let's
1755 * suppress this, if we can */
1759 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1762 r = bus_write_message(bus, m, hint_sync_call, &idx);
1764 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1765 bus_enter_closing(bus);
1772 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1773 /* Wasn't fully written. So let's remember how
1774 * much was written. Note that the first entry
1775 * of the wqueue array is always allocated so
1776 * that we always can remember how much was
1778 bus->wqueue[0] = sd_bus_message_ref(m);
1779 bus->wqueue_size = 1;
1784 /* Just append it to the queue. */
1786 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1789 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1792 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1797 *cookie = BUS_MESSAGE_COOKIE(m);
1802 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1803 return bus_send_internal(bus, m, cookie, false);
1806 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1809 assert_return(m, -EINVAL);
1814 assert_return(!bus_pid_changed(bus), -ECHILD);
1816 if (!BUS_IS_OPEN(bus->state))
1819 if (!streq_ptr(m->destination, destination)) {
1824 r = sd_bus_message_set_destination(m, destination);
1829 return sd_bus_send(bus, m, cookie);
1832 static usec_t calc_elapse(uint64_t usec) {
1833 if (usec == (uint64_t) -1)
1836 return now(CLOCK_MONOTONIC) + usec;
1839 static int timeout_compare(const void *a, const void *b) {
1840 const struct reply_callback *x = a, *y = b;
1842 if (x->timeout != 0 && y->timeout == 0)
1845 if (x->timeout == 0 && y->timeout != 0)
1848 if (x->timeout < y->timeout)
1851 if (x->timeout > y->timeout)
1857 _public_ int sd_bus_call_async(
1861 sd_bus_message_handler_t callback,
1865 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1866 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1869 assert_return(m, -EINVAL);
1870 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1871 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1872 assert_return(callback, -EINVAL);
1877 assert_return(!bus_pid_changed(bus), -ECHILD);
1878 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1880 if (!BUS_IS_OPEN(bus->state))
1883 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1887 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1891 r = bus_seal_message(bus, m, usec);
1895 r = bus_remarshal_message(bus, &m);
1899 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1903 s->reply_callback.callback = callback;
1905 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1906 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1908 s->reply_callback.cookie = 0;
1912 s->reply_callback.timeout = calc_elapse(m->timeout);
1913 if (s->reply_callback.timeout != 0) {
1914 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1916 s->reply_callback.timeout = 0;
1921 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1932 int bus_ensure_running(sd_bus *bus) {
1937 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1939 if (bus->state == BUS_RUNNING)
1943 r = sd_bus_process(bus, NULL);
1946 if (bus->state == BUS_RUNNING)
1951 r = sd_bus_wait(bus, (uint64_t) -1);
1957 _public_ int sd_bus_call(
1961 sd_bus_error *error,
1962 sd_bus_message **reply) {
1964 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1970 assert_return(m, -EINVAL);
1971 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1972 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1973 assert_return(!bus_error_is_dirty(error), -EINVAL);
1978 assert_return(!bus_pid_changed(bus), -ECHILD);
1979 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1981 if (!BUS_IS_OPEN(bus->state))
1984 r = bus_ensure_running(bus);
1988 i = bus->rqueue_size;
1990 r = bus_seal_message(bus, m, usec);
1994 r = bus_remarshal_message(bus, &m);
1998 r = bus_send_internal(bus, m, &cookie, true);
2002 timeout = calc_elapse(m->timeout);
2007 while (i < bus->rqueue_size) {
2008 sd_bus_message *incoming = NULL;
2010 incoming = bus->rqueue[i];
2012 if (incoming->reply_cookie == cookie) {
2013 /* Found a match! */
2015 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2017 log_debug_bus_message(incoming);
2019 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2021 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2025 sd_bus_message_unref(incoming);
2030 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2032 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
2033 r = sd_bus_error_copy(error, &incoming->error);
2037 sd_bus_message_unref(incoming);
2040 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2043 streq(bus->unique_name, incoming->sender)) {
2045 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2048 /* Our own message? Somebody is trying
2049 * to send its own client a message,
2050 * let's not dead-lock, let's fail
2053 sd_bus_message_unref(incoming);
2057 /* Try to read more, right-away */
2061 r = bus_read_message(bus, false, 0);
2063 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2064 bus_enter_closing(bus);
2076 n = now(CLOCK_MONOTONIC);
2082 left = (uint64_t) -1;
2084 r = bus_poll(bus, true, left);
2090 r = dispatch_wqueue(bus);
2092 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2093 bus_enter_closing(bus);
2102 _public_ int sd_bus_get_fd(sd_bus *bus) {
2104 assert_return(bus, -EINVAL);
2105 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2106 assert_return(!bus_pid_changed(bus), -ECHILD);
2108 return bus->input_fd;
2111 _public_ int sd_bus_get_events(sd_bus *bus) {
2114 assert_return(bus, -EINVAL);
2115 assert_return(!bus_pid_changed(bus), -ECHILD);
2117 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2120 if (bus->state == BUS_OPENING)
2122 else if (bus->state == BUS_AUTHENTICATING) {
2124 if (bus_socket_auth_needs_write(bus))
2129 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2130 if (bus->rqueue_size <= 0)
2132 if (bus->wqueue_size > 0)
2139 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2140 struct reply_callback *c;
2142 assert_return(bus, -EINVAL);
2143 assert_return(timeout_usec, -EINVAL);
2144 assert_return(!bus_pid_changed(bus), -ECHILD);
2146 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2149 if (bus->track_queue) {
2154 if (bus->state == BUS_CLOSING) {
2159 if (bus->state == BUS_AUTHENTICATING) {
2160 *timeout_usec = bus->auth_timeout;
2164 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2165 *timeout_usec = (uint64_t) -1;
2169 if (bus->rqueue_size > 0) {
2174 c = prioq_peek(bus->reply_callbacks_prioq);
2176 *timeout_usec = (uint64_t) -1;
2180 if (c->timeout == 0) {
2181 *timeout_usec = (uint64_t) -1;
2185 *timeout_usec = c->timeout;
2189 static int process_timeout(sd_bus *bus) {
2190 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2191 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2192 struct reply_callback *c;
2199 c = prioq_peek(bus->reply_callbacks_prioq);
2203 n = now(CLOCK_MONOTONIC);
2207 r = bus_message_new_synthetic_error(
2210 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2215 r = bus_seal_synthetic_message(bus, m);
2219 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2222 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2225 slot = container_of(c, sd_bus_slot, reply_callback);
2227 bus->iteration_counter ++;
2229 bus->current_message = m;
2230 bus->current_slot = sd_bus_slot_ref(slot);
2231 bus->current_handler = c->callback;
2232 bus->current_userdata = slot->userdata;
2233 r = c->callback(m, slot->userdata, &error_buffer);
2234 bus->current_userdata = NULL;
2235 bus->current_handler = NULL;
2236 bus->current_slot = NULL;
2237 bus->current_message = NULL;
2239 if (slot->floating) {
2240 bus_slot_disconnect(slot);
2241 sd_bus_slot_unref(slot);
2244 sd_bus_slot_unref(slot);
2246 return bus_maybe_reply_error(m, r, &error_buffer);
2249 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2253 if (bus->state != BUS_HELLO)
2256 /* Let's make sure the first message on the bus is the HELLO
2257 * reply. But note that we don't actually parse the message
2258 * here (we leave that to the usual handling), we just verify
2259 * we don't let any earlier msg through. */
2261 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2262 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2265 if (m->reply_cookie != 1)
2271 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2272 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2273 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2274 struct reply_callback *c;
2281 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2282 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2285 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2288 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2291 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2297 slot = container_of(c, sd_bus_slot, reply_callback);
2299 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2301 /* If the reply contained a file descriptor which we
2302 * didn't want we pass an error instead. */
2304 r = bus_message_new_synthetic_error(
2307 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2312 /* Copy over original timestamp */
2313 synthetic_reply->realtime = m->realtime;
2314 synthetic_reply->monotonic = m->monotonic;
2315 synthetic_reply->seqnum = m->seqnum;
2317 r = bus_seal_synthetic_message(bus, synthetic_reply);
2321 m = synthetic_reply;
2323 r = sd_bus_message_rewind(m, true);
2328 if (c->timeout != 0) {
2329 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2333 bus->current_slot = sd_bus_slot_ref(slot);
2334 bus->current_handler = c->callback;
2335 bus->current_userdata = slot->userdata;
2336 r = c->callback(m, slot->userdata, &error_buffer);
2337 bus->current_userdata = NULL;
2338 bus->current_handler = NULL;
2339 bus->current_slot = NULL;
2341 if (slot->floating) {
2342 bus_slot_disconnect(slot);
2343 sd_bus_slot_unref(slot);
2346 sd_bus_slot_unref(slot);
2348 return bus_maybe_reply_error(m, r, &error_buffer);
2351 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2352 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2353 struct filter_callback *l;
2360 bus->filter_callbacks_modified = false;
2362 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2365 if (bus->filter_callbacks_modified)
2368 /* Don't run this more than once per iteration */
2369 if (l->last_iteration == bus->iteration_counter)
2372 l->last_iteration = bus->iteration_counter;
2374 r = sd_bus_message_rewind(m, true);
2378 slot = container_of(l, sd_bus_slot, filter_callback);
2380 bus->current_slot = sd_bus_slot_ref(slot);
2381 bus->current_handler = l->callback;
2382 bus->current_userdata = slot->userdata;
2383 r = l->callback(m, slot->userdata, &error_buffer);
2384 bus->current_userdata = NULL;
2385 bus->current_handler = NULL;
2386 bus->current_slot = sd_bus_slot_unref(slot);
2388 r = bus_maybe_reply_error(m, r, &error_buffer);
2394 } while (bus->filter_callbacks_modified);
2399 static int process_match(sd_bus *bus, sd_bus_message *m) {
2406 bus->match_callbacks_modified = false;
2408 r = bus_match_run(bus, &bus->match_callbacks, m);
2412 } while (bus->match_callbacks_modified);
2417 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2418 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2424 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2427 if (bus->manual_peer_interface)
2430 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2433 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2436 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2439 if (streq_ptr(m->member, "Ping"))
2440 r = sd_bus_message_new_method_return(m, &reply);
2441 else if (streq_ptr(m->member, "GetMachineId")) {
2445 r = sd_id128_get_machine(&id);
2449 r = sd_bus_message_new_method_return(m, &reply);
2453 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2455 r = sd_bus_message_new_method_errorf(
2457 SD_BUS_ERROR_UNKNOWN_METHOD,
2458 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2464 r = sd_bus_send(bus, reply, NULL);
2471 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2475 /* If we got a message with a file descriptor which we didn't
2476 * want to accept, then let's drop it. How can this even
2477 * happen? For example, when the kernel queues a message into
2478 * an activatable names's queue which allows fds, and then is
2479 * delivered to us later even though we ourselves did not
2482 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2488 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2491 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2492 return 1; /* just eat it up */
2494 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2497 static int process_message(sd_bus *bus, sd_bus_message *m) {
2503 bus->current_message = m;
2504 bus->iteration_counter++;
2506 log_debug_bus_message(m);
2508 r = process_hello(bus, m);
2512 r = process_reply(bus, m);
2516 r = process_fd_check(bus, m);
2520 r = process_filter(bus, m);
2524 r = process_match(bus, m);
2528 r = process_builtin(bus, m);
2532 r = bus_process_object(bus, m);
2535 bus->current_message = NULL;
2539 static int dispatch_track(sd_bus *bus) {
2542 if (!bus->track_queue)
2545 bus_track_dispatch(bus->track_queue);
2549 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2550 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2554 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2556 r = process_timeout(bus);
2560 r = dispatch_wqueue(bus);
2564 r = dispatch_track(bus);
2568 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2574 r = process_message(bus, m);
2579 r = sd_bus_message_rewind(m, true);
2588 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2590 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2591 strna(sd_bus_message_get_sender(m)),
2592 strna(sd_bus_message_get_path(m)),
2593 strna(sd_bus_message_get_interface(m)),
2594 strna(sd_bus_message_get_member(m)));
2596 r = sd_bus_reply_method_errorf(
2598 SD_BUS_ERROR_UNKNOWN_OBJECT,
2599 "Unknown object '%s'.", m->path);
2613 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2614 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2615 struct reply_callback *c;
2619 assert(bus->state == BUS_CLOSING);
2621 c = ordered_hashmap_first(bus->reply_callbacks);
2623 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2626 /* First, fail all outstanding method calls */
2627 r = bus_message_new_synthetic_error(
2630 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2635 r = bus_seal_synthetic_message(bus, m);
2639 if (c->timeout != 0) {
2640 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2644 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2647 slot = container_of(c, sd_bus_slot, reply_callback);
2649 bus->iteration_counter++;
2651 bus->current_message = m;
2652 bus->current_slot = sd_bus_slot_ref(slot);
2653 bus->current_handler = c->callback;
2654 bus->current_userdata = slot->userdata;
2655 r = c->callback(m, slot->userdata, &error_buffer);
2656 bus->current_userdata = NULL;
2657 bus->current_handler = NULL;
2658 bus->current_slot = NULL;
2659 bus->current_message = NULL;
2661 if (slot->floating) {
2662 bus_slot_disconnect(slot);
2663 sd_bus_slot_unref(slot);
2666 sd_bus_slot_unref(slot);
2668 return bus_maybe_reply_error(m, r, &error_buffer);
2671 /* Then, synthesize a Disconnected message */
2672 r = sd_bus_message_new_signal(
2675 "/org/freedesktop/DBus/Local",
2676 "org.freedesktop.DBus.Local",
2681 bus_message_set_sender_local(bus, m);
2683 r = bus_seal_synthetic_message(bus, m);
2689 bus->current_message = m;
2690 bus->iteration_counter++;
2692 r = process_filter(bus, m);
2696 r = process_match(bus, m);
2708 bus->current_message = NULL;
2713 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2714 BUS_DONT_DESTROY(bus);
2717 /* Returns 0 when we didn't do anything. This should cause the
2718 * caller to invoke sd_bus_wait() before returning the next
2719 * time. Returns > 0 when we did something, which possibly
2720 * means *ret is filled in with an unprocessed message. */
2722 assert_return(bus, -EINVAL);
2723 assert_return(!bus_pid_changed(bus), -ECHILD);
2725 /* We don't allow recursively invoking sd_bus_process(). */
2726 assert_return(!bus->current_message, -EBUSY);
2727 assert(!bus->current_slot);
2729 switch (bus->state) {
2738 r = bus_socket_process_opening(bus);
2739 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2740 bus_enter_closing(bus);
2748 case BUS_AUTHENTICATING:
2749 r = bus_socket_process_authenticating(bus);
2750 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2751 bus_enter_closing(bus);
2763 r = process_running(bus, hint_priority, priority, ret);
2764 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2765 bus_enter_closing(bus);
2775 return process_closing(bus, ret);
2778 assert_not_reached("Unknown state");
2781 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2782 return bus_process_internal(bus, false, 0, ret);
2785 /// UNNEEDED by elogind
2787 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2788 return bus_process_internal(bus, true, priority, ret);
2792 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2793 struct pollfd p[2] = {};
2796 usec_t m = USEC_INFINITY;
2800 if (bus->state == BUS_CLOSING)
2803 if (!BUS_IS_OPEN(bus->state))
2806 e = sd_bus_get_events(bus);
2811 /* The caller really needs some more data, he doesn't
2812 * care about what's already read, or any timeouts
2813 * except its own. */
2817 /* The caller wants to process if there's something to
2818 * process, but doesn't care otherwise */
2820 r = sd_bus_get_timeout(bus, &until);
2825 nw = now(CLOCK_MONOTONIC);
2826 m = until > nw ? until - nw : 0;
2830 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2833 p[0].fd = bus->input_fd;
2834 if (bus->output_fd == bus->input_fd) {
2838 p[0].events = e & POLLIN;
2839 p[1].fd = bus->output_fd;
2840 p[1].events = e & POLLOUT;
2844 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2848 return r > 0 ? 1 : 0;
2851 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2853 assert_return(bus, -EINVAL);
2854 assert_return(!bus_pid_changed(bus), -ECHILD);
2856 if (bus->state == BUS_CLOSING)
2859 if (!BUS_IS_OPEN(bus->state))
2862 if (bus->rqueue_size > 0)
2865 return bus_poll(bus, false, timeout_usec);
2868 _public_ int sd_bus_flush(sd_bus *bus) {
2871 assert_return(bus, -EINVAL);
2872 assert_return(!bus_pid_changed(bus), -ECHILD);
2874 if (bus->state == BUS_CLOSING)
2877 if (!BUS_IS_OPEN(bus->state))
2880 r = bus_ensure_running(bus);
2884 if (bus->wqueue_size <= 0)
2888 r = dispatch_wqueue(bus);
2890 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2891 bus_enter_closing(bus);
2898 if (bus->wqueue_size <= 0)
2901 r = bus_poll(bus, false, (uint64_t) -1);
2907 _public_ int sd_bus_add_filter(
2910 sd_bus_message_handler_t callback,
2915 assert_return(bus, -EINVAL);
2916 assert_return(callback, -EINVAL);
2917 assert_return(!bus_pid_changed(bus), -ECHILD);
2919 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2923 s->filter_callback.callback = callback;
2925 bus->filter_callbacks_modified = true;
2926 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2934 _public_ int sd_bus_add_match(
2938 sd_bus_message_handler_t callback,
2941 struct bus_match_component *components = NULL;
2942 unsigned n_components = 0;
2943 sd_bus_slot *s = NULL;
2946 assert_return(bus, -EINVAL);
2947 assert_return(match, -EINVAL);
2948 assert_return(!bus_pid_changed(bus), -ECHILD);
2950 r = bus_match_parse(match, &components, &n_components);
2954 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2960 s->match_callback.callback = callback;
2961 s->match_callback.cookie = ++bus->match_cookie;
2963 if (bus->bus_client) {
2964 enum bus_match_scope scope;
2966 scope = bus_match_get_scope(components, n_components);
2968 /* Do not install server-side matches for matches
2969 * against the local service, interface or bus
2971 if (scope != BUS_MATCH_LOCAL) {
2973 if (!bus->is_kernel) {
2974 /* When this is not a kernel transport, we
2975 * store the original match string, so that we
2976 * can use it to remove the match again */
2978 s->match_callback.match_string = strdup(match);
2979 if (!s->match_callback.match_string) {
2985 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2989 s->match_added = true;
2993 bus->match_callbacks_modified = true;
2994 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3003 bus_match_parse_free(components, n_components);
3004 sd_bus_slot_unref(s);
3009 /// UNNEEDED by elogind
3011 int bus_remove_match_by_string(
3014 sd_bus_message_handler_t callback,
3017 struct bus_match_component *components = NULL;
3018 unsigned n_components = 0;
3019 struct match_callback *c;
3022 assert_return(bus, -EINVAL);
3023 assert_return(match, -EINVAL);
3024 assert_return(!bus_pid_changed(bus), -ECHILD);
3026 r = bus_match_parse(match, &components, &n_components);
3030 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3034 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3037 bus_match_parse_free(components, n_components);
3043 bool bus_pid_changed(sd_bus *bus) {
3046 /* We don't support people creating a bus connection and
3047 * keeping it around over a fork(). Let's complain. */
3049 return bus->original_pid != getpid();
3052 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3053 sd_bus *bus = userdata;
3058 r = sd_bus_process(bus, NULL);
3065 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3066 sd_bus *bus = userdata;
3071 r = sd_bus_process(bus, NULL);
3078 static int prepare_callback(sd_event_source *s, void *userdata) {
3079 sd_bus *bus = userdata;
3086 e = sd_bus_get_events(bus);
3090 if (bus->output_fd != bus->input_fd) {
3092 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3096 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3100 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3105 r = sd_bus_get_timeout(bus, &until);
3111 j = sd_event_source_set_time(bus->time_event_source, until);
3116 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3123 static int quit_callback(sd_event_source *event, void *userdata) {
3124 sd_bus *bus = userdata;
3134 static int attach_io_events(sd_bus *bus) {
3139 if (bus->input_fd < 0)
3145 if (!bus->input_io_event_source) {
3146 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3150 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3154 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3158 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3160 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3165 if (bus->output_fd != bus->input_fd) {
3166 assert(bus->output_fd >= 0);
3168 if (!bus->output_io_event_source) {
3169 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3173 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3177 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3179 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3188 static void detach_io_events(sd_bus *bus) {
3191 if (bus->input_io_event_source) {
3192 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3193 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3196 if (bus->output_io_event_source) {
3197 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3198 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3202 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3205 assert_return(bus, -EINVAL);
3206 assert_return(!bus->event, -EBUSY);
3208 assert(!bus->input_io_event_source);
3209 assert(!bus->output_io_event_source);
3210 assert(!bus->time_event_source);
3213 bus->event = sd_event_ref(event);
3215 r = sd_event_default(&bus->event);
3220 bus->event_priority = priority;
3222 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3226 r = sd_event_source_set_priority(bus->time_event_source, priority);
3230 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3234 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3238 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3242 r = attach_io_events(bus);
3249 sd_bus_detach_event(bus);
3253 _public_ int sd_bus_detach_event(sd_bus *bus) {
3254 assert_return(bus, -EINVAL);
3259 detach_io_events(bus);
3261 if (bus->time_event_source) {
3262 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3263 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3266 if (bus->quit_event_source) {
3267 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3268 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3271 bus->event = sd_event_unref(bus->event);
3275 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3276 assert_return(bus, NULL);
3281 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3282 assert_return(bus, NULL);
3284 return bus->current_message;
3287 /// UNNEEDED by elogind
3289 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3290 assert_return(bus, NULL);
3292 return bus->current_slot;
3296 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3297 assert_return(bus, NULL);
3299 return bus->current_handler;
3302 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3303 assert_return(bus, NULL);
3305 return bus->current_userdata;
3308 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3313 assert(default_bus);
3316 return !!*default_bus;
3319 *ret = sd_bus_ref(*default_bus);
3327 b->default_bus_ptr = default_bus;
3335 _public_ int sd_bus_default_system(sd_bus **ret) {
3336 static thread_local sd_bus *default_system_bus = NULL;
3338 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3341 _public_ int sd_bus_default_user(sd_bus **ret) {
3342 static thread_local sd_bus *default_user_bus = NULL;
3344 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3347 _public_ int sd_bus_default(sd_bus **ret) {
3351 /* Let's try our best to reuse another cached connection. If
3352 * the starter bus type is set, connect via our normal
3353 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3354 * we can share the connection with the user/system default
3357 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3359 if (streq(e, "system"))
3360 return sd_bus_default_system(ret);
3361 else if (STR_IN_SET(e, "user", "session"))
3362 return sd_bus_default_user(ret);
3365 /* No type is specified, so we have not other option than to
3366 * use the starter address if it is set. */
3368 e = secure_getenv("DBUS_STARTER_ADDRESS");
3370 static thread_local sd_bus *default_starter_bus = NULL;
3372 return bus_default(sd_bus_open, &default_starter_bus, ret);
3375 /* Finally, if nothing is set use the cached connection for
3376 * the right scope */
3378 return sd_bus_default_system(ret);
3381 /// UNNEEDED by elogind
3383 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3384 assert_return(b, -EINVAL);
3385 assert_return(tid, -EINVAL);
3386 assert_return(!bus_pid_changed(b), -ECHILD);
3394 return sd_event_get_tid(b->event, tid);
3399 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3400 _cleanup_free_ char *e = NULL;
3403 assert_return(object_path_is_valid(prefix), -EINVAL);
3404 assert_return(external_id, -EINVAL);
3405 assert_return(ret_path, -EINVAL);
3407 e = bus_label_escape(external_id);
3411 ret = strjoin(prefix, "/", e, NULL);
3419 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3423 assert_return(object_path_is_valid(path), -EINVAL);
3424 assert_return(object_path_is_valid(prefix), -EINVAL);
3425 assert_return(external_id, -EINVAL);
3427 e = object_path_startswith(path, prefix);
3429 *external_id = NULL;
3433 ret = bus_label_unescape(e);
3442 _public_ int sd_bus_try_close(sd_bus *bus) {
3445 assert_return(bus, -EINVAL);
3446 assert_return(!bus_pid_changed(bus), -ECHILD);
3448 if (!bus->is_kernel)
3451 if (!BUS_IS_OPEN(bus->state))
3454 if (bus->rqueue_size > 0)
3457 if (bus->wqueue_size > 0)
3460 r = bus_kernel_try_close(bus);
3468 /// UNNEEDED by elogind
3470 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3471 assert_return(bus, -EINVAL);
3472 assert_return(description, -EINVAL);
3473 assert_return(bus->description, -ENXIO);
3474 assert_return(!bus_pid_changed(bus), -ECHILD);
3476 *description = bus->description;
3481 int bus_get_root_path(sd_bus *bus) {
3484 if (bus->cgroup_root)
3487 r = cg_get_root_path(&bus->cgroup_root);
3489 bus->cgroup_root = strdup("/");
3490 if (!bus->cgroup_root)
3499 /// UNNEEDED by elogind
3501 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3504 assert_return(bus, -EINVAL);
3505 assert_return(scope, -EINVAL);
3506 assert_return(!bus_pid_changed(bus), -ECHILD);
3508 if (bus->is_kernel) {
3509 _cleanup_free_ char *n = NULL;
3512 r = bus_kernel_get_bus_name(bus, &n);
3516 if (streq(n, "0-system")) {
3521 dash = strchr(n, '-');
3522 if (streq_ptr(dash, "-user")) {
3533 if (bus->is_system) {
3541 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3543 assert_return(bus, -EINVAL);
3544 assert_return(address, -EINVAL);
3545 assert_return(!bus_pid_changed(bus), -ECHILD);
3548 *address = bus->address;
3555 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3556 assert_return(bus, -EINVAL);
3557 assert_return(mask, -EINVAL);
3558 assert_return(!bus_pid_changed(bus), -ECHILD);
3560 *mask = bus->creds_mask;
3564 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3565 assert_return(bus, -EINVAL);
3566 assert_return(!bus_pid_changed(bus), -ECHILD);
3568 return bus->bus_client;
3571 _public_ int sd_bus_is_server(sd_bus *bus) {
3572 assert_return(bus, -EINVAL);
3573 assert_return(!bus_pid_changed(bus), -ECHILD);
3575 return bus->is_server;
3578 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3579 assert_return(bus, -EINVAL);
3580 assert_return(!bus_pid_changed(bus), -ECHILD);
3582 return bus->anonymous_auth;
3585 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3586 assert_return(bus, -EINVAL);
3587 assert_return(!bus_pid_changed(bus), -ECHILD);
3589 return bus->trusted;
3592 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3593 assert_return(bus, -EINVAL);
3594 assert_return(!bus_pid_changed(bus), -ECHILD);
3596 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);