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 "hostname-util.h"
37 #include "bus-label.h"
40 #include "bus-internal.h"
41 #include "bus-message.h"
43 #include "bus-socket.h"
44 #include "bus-kernel.h"
45 #include "bus-control.h"
46 #include "bus-objects.h"
48 #include "bus-container.h"
49 #include "bus-protocol.h"
50 #include "bus-track.h"
53 #define log_debug_bus_message(m) \
55 sd_bus_message *_mm = (m); \
56 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
57 bus_message_type_to_string(_mm->header->type), \
58 strna(sd_bus_message_get_sender(_mm)), \
59 strna(sd_bus_message_get_destination(_mm)), \
60 strna(sd_bus_message_get_path(_mm)), \
61 strna(sd_bus_message_get_interface(_mm)), \
62 strna(sd_bus_message_get_member(_mm)), \
63 BUS_MESSAGE_COOKIE(_mm), \
65 strna(_mm->error.message)); \
68 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
69 static int attach_io_events(sd_bus *b);
70 static void detach_io_events(sd_bus *b);
72 static void bus_close_fds(sd_bus *b) {
77 if (b->input_fd != b->output_fd)
78 safe_close(b->output_fd);
79 b->output_fd = b->input_fd = safe_close(b->input_fd);
82 static void bus_reset_queues(sd_bus *b) {
85 while (b->rqueue_size > 0)
86 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
88 b->rqueue = mfree(b->rqueue);
89 b->rqueue_allocated = 0;
91 while (b->wqueue_size > 0)
92 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
94 b->wqueue = mfree(b->wqueue);
95 b->wqueue_allocated = 0;
98 static void bus_free(sd_bus *b) {
102 assert(!b->track_queue);
104 b->state = BUS_CLOSED;
106 sd_bus_detach_event(b);
108 while ((s = b->slots)) {
109 /* At this point only floating slots can still be
110 * around, because the non-floating ones keep a
111 * reference to the bus, and we thus couldn't be
112 * destructing right now... We forcibly disconnect the
113 * slots here, so that they still can be referenced by
114 * apps, but are dead. */
117 bus_slot_disconnect(s);
118 sd_bus_slot_unref(s);
121 if (b->default_bus_ptr)
122 *b->default_bus_ptr = NULL;
127 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
131 free(b->unique_name);
132 free(b->auth_buffer);
137 free(b->cgroup_root);
138 free(b->description);
141 strv_free(b->exec_argv);
143 close_many(b->fds, b->n_fds);
148 ordered_hashmap_free_free(b->reply_callbacks);
149 prioq_free(b->reply_callbacks_prioq);
151 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
152 bus_match_free(&b->match_callbacks);
154 hashmap_free_free(b->vtable_methods);
155 hashmap_free_free(b->vtable_properties);
157 assert(hashmap_isempty(b->nodes));
158 hashmap_free(b->nodes);
160 bus_kernel_flush_memfd(b);
162 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
167 _public_ int sd_bus_new(sd_bus **ret) {
170 assert_return(ret, -EINVAL);
176 r->n_ref = REFCNT_INIT;
177 r->input_fd = r->output_fd = -1;
178 r->message_version = 1;
179 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
180 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
181 r->attach_flags |= KDBUS_ATTACH_NAMES;
182 r->original_pid = getpid();
184 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
186 /* We guarantee that wqueue always has space for at least one
188 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
197 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
200 assert_return(bus, -EINVAL);
201 assert_return(bus->state == BUS_UNSET, -EPERM);
202 assert_return(address, -EINVAL);
203 assert_return(!bus_pid_changed(bus), -ECHILD);
215 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
216 assert_return(bus, -EINVAL);
217 assert_return(bus->state == BUS_UNSET, -EPERM);
218 assert_return(input_fd >= 0, -EBADF);
219 assert_return(output_fd >= 0, -EBADF);
220 assert_return(!bus_pid_changed(bus), -ECHILD);
222 bus->input_fd = input_fd;
223 bus->output_fd = output_fd;
227 /// UNNEEDED by elogind
229 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
232 assert_return(bus, -EINVAL);
233 assert_return(bus->state == BUS_UNSET, -EPERM);
234 assert_return(path, -EINVAL);
235 assert_return(!strv_isempty(argv), -EINVAL);
236 assert_return(!bus_pid_changed(bus), -ECHILD);
248 free(bus->exec_path);
249 strv_free(bus->exec_argv);
257 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
258 assert_return(bus, -EINVAL);
259 assert_return(bus->state == BUS_UNSET, -EPERM);
260 assert_return(!bus_pid_changed(bus), -ECHILD);
262 bus->bus_client = !!b;
266 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
267 assert_return(bus, -EINVAL);
268 assert_return(bus->state == BUS_UNSET, -EPERM);
269 assert_return(!bus_pid_changed(bus), -ECHILD);
271 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
275 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
276 assert_return(bus, -EINVAL);
277 assert_return(bus->state == BUS_UNSET, -EPERM);
278 assert_return(!bus_pid_changed(bus), -ECHILD);
280 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
284 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
286 assert_return(bus, -EINVAL);
287 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
288 assert_return(!bus_pid_changed(bus), -ECHILD);
290 new_flags = bus->attach_flags;
291 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
293 if (bus->attach_flags == new_flags)
296 bus->attach_flags = new_flags;
297 if (bus->state != BUS_UNSET && bus->is_kernel)
298 bus_kernel_realize_attach_flags(bus);
304 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
307 assert_return(bus, -EINVAL);
308 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
309 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
310 assert_return(!bus_pid_changed(bus), -ECHILD);
313 bus->creds_mask |= mask;
315 bus->creds_mask &= ~mask;
317 /* The well knowns we need unconditionally, so that matches can work */
318 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
320 /* Make sure we don't lose the timestamp flag */
321 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
322 if (bus->attach_flags == new_flags)
325 bus->attach_flags = new_flags;
326 if (bus->state != BUS_UNSET && bus->is_kernel)
327 bus_kernel_realize_attach_flags(bus);
332 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
333 assert_return(bus, -EINVAL);
334 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
335 assert_return(bus->state == BUS_UNSET, -EPERM);
336 assert_return(!bus_pid_changed(bus), -ECHILD);
338 bus->is_server = !!b;
339 bus->server_id = server_id;
343 /// UNNEEDED by elogind
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);
372 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
373 assert_return(bus, -EINVAL);
374 assert_return(!bus_pid_changed(bus), -ECHILD);
376 bus->allow_interactive_authorization = !!b;
380 /// UNNEEDED by elogind
382 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
383 assert_return(bus, -EINVAL);
384 assert_return(!bus_pid_changed(bus), -ECHILD);
386 return bus->allow_interactive_authorization;
390 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
398 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
400 r = sd_bus_message_get_errno(reply);
404 r = sd_bus_message_read(reply, "s", &s);
408 if (!service_name_is_valid(s) || s[0] != ':')
411 bus->unique_name = strdup(s);
412 if (!bus->unique_name)
415 if (bus->state == BUS_HELLO)
416 bus->state = BUS_RUNNING;
421 static int bus_send_hello(sd_bus *bus) {
422 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
427 if (!bus->bus_client || bus->is_kernel)
430 r = sd_bus_message_new_method_call(
433 "org.freedesktop.DBus",
434 "/org/freedesktop/DBus",
435 "org.freedesktop.DBus",
440 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
443 int bus_start_running(sd_bus *bus) {
446 if (bus->bus_client && !bus->is_kernel) {
447 bus->state = BUS_HELLO;
451 bus->state = BUS_RUNNING;
455 static int parse_address_key(const char **p, const char *key, char **value) {
456 size_t l, n = 0, allocated = 0;
466 if (strncmp(*p, key, l) != 0)
479 while (*a != ';' && *a != ',' && *a != 0) {
497 c = (char) ((x << 4) | y);
504 if (!GREEDY_REALLOC(r, allocated, n + 2))
528 static void skip_address_key(const char **p) {
532 *p += strcspn(*p, ",");
538 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
539 _cleanup_free_ char *path = NULL, *abstract = NULL;
548 while (**p != 0 && **p != ';') {
549 r = parse_address_key(p, "guid", guid);
555 r = parse_address_key(p, "path", &path);
561 r = parse_address_key(p, "abstract", &abstract);
570 if (!path && !abstract)
573 if (path && abstract)
578 if (l > sizeof(b->sockaddr.un.sun_path))
581 b->sockaddr.un.sun_family = AF_UNIX;
582 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
583 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
584 } else if (abstract) {
585 l = strlen(abstract);
586 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
589 b->sockaddr.un.sun_family = AF_UNIX;
590 b->sockaddr.un.sun_path[0] = 0;
591 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
592 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
598 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
599 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
601 struct addrinfo *result, hints = {
602 .ai_socktype = SOCK_STREAM,
603 .ai_flags = AI_ADDRCONFIG,
611 while (**p != 0 && **p != ';') {
612 r = parse_address_key(p, "guid", guid);
618 r = parse_address_key(p, "host", &host);
624 r = parse_address_key(p, "port", &port);
630 r = parse_address_key(p, "family", &family);
643 if (streq(family, "ipv4"))
644 hints.ai_family = AF_INET;
645 else if (streq(family, "ipv6"))
646 hints.ai_family = AF_INET6;
651 r = getaddrinfo(host, port, &hints, &result);
655 return -EADDRNOTAVAIL;
657 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
658 b->sockaddr_size = result->ai_addrlen;
660 freeaddrinfo(result);
665 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
667 unsigned n_argv = 0, j;
669 size_t allocated = 0;
677 while (**p != 0 && **p != ';') {
678 r = parse_address_key(p, "guid", guid);
684 r = parse_address_key(p, "path", &path);
690 if (startswith(*p, "argv")) {
694 ul = strtoul(*p + 4, (char**) p, 10);
695 if (errno > 0 || **p != '=' || ul > 256) {
703 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
711 r = parse_address_key(p, NULL, argv + ul);
726 /* Make sure there are no holes in the array, with the
727 * exception of argv[0] */
728 for (j = 1; j < n_argv; j++)
734 if (argv && argv[0] == NULL) {
735 argv[0] = strdup(path);
747 for (j = 0; j < n_argv; j++)
755 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
756 _cleanup_free_ char *path = NULL;
764 while (**p != 0 && **p != ';') {
765 r = parse_address_key(p, "guid", guid);
771 r = parse_address_key(p, "path", &path);
790 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
791 _cleanup_free_ char *machine = NULL, *pid = NULL;
799 while (**p != 0 && **p != ';') {
800 r = parse_address_key(p, "guid", guid);
806 r = parse_address_key(p, "machine", &machine);
812 r = parse_address_key(p, "pid", &pid);
821 if (!machine == !pid)
825 if (!machine_name_is_valid(machine))
829 b->machine = machine;
837 r = parse_pid(pid, &b->nspid);
843 b->sockaddr.un.sun_family = AF_UNIX;
844 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
845 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
850 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
851 _cleanup_free_ char *machine = NULL, *pid = NULL;
859 while (**p != 0 && **p != ';') {
860 r = parse_address_key(p, "guid", guid);
866 r = parse_address_key(p, "machine", &machine);
872 r = parse_address_key(p, "pid", &pid);
881 if (!machine == !pid)
885 if (!machine_name_is_valid(machine))
889 b->machine = machine;
897 r = parse_pid(pid, &b->nspid);
903 r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
910 static void bus_reset_parsed_address(sd_bus *b) {
914 b->sockaddr_size = 0;
915 b->exec_argv = strv_free(b->exec_argv);
916 b->exec_path = mfree(b->exec_path);
917 b->server_id = SD_ID128_NULL;
918 b->kernel = mfree(b->kernel);
919 b->machine = mfree(b->machine);
923 static int bus_parse_next_address(sd_bus *b) {
924 _cleanup_free_ char *guid = NULL;
932 if (b->address[b->address_index] == 0)
935 bus_reset_parsed_address(b);
937 a = b->address + b->address_index;
946 if (startswith(a, "unix:")) {
949 r = parse_unix_address(b, &a, &guid);
954 } else if (startswith(a, "tcp:")) {
957 r = parse_tcp_address(b, &a, &guid);
963 } else if (startswith(a, "unixexec:")) {
966 r = parse_exec_address(b, &a, &guid);
972 } else if (startswith(a, "kernel:")) {
975 r = parse_kernel_address(b, &a, &guid);
980 } else if (startswith(a, "x-machine-unix:")) {
983 r = parse_container_unix_address(b, &a, &guid);
988 } else if (startswith(a, "x-machine-kernel:")) {
991 r = parse_container_kernel_address(b, &a, &guid);
1004 r = sd_id128_from_string(guid, &b->server_id);
1009 b->address_index = a - b->address;
1013 static int bus_start_address(sd_bus *b) {
1014 bool container_kdbus_available = false;
1015 bool kdbus_available = false;
1021 bool skipped = false;
1026 * Usually, if you provide multiple different bus-addresses, we
1027 * try all of them in order. We use the first one that
1028 * succeeds. However, if you mix kernel and unix addresses, we
1029 * never try unix-addresses if a previous kernel address was
1030 * tried and kdbus was available. This is required to prevent
1031 * clients to fallback to the bus-proxy if kdbus is available
1032 * but failed (eg., too many connections).
1036 r = bus_socket_exec(b);
1038 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1039 r = bus_container_connect_kernel(b);
1040 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1041 container_kdbus_available = true;
1043 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1044 if (!container_kdbus_available)
1045 r = bus_container_connect_socket(b);
1049 } else if (b->kernel) {
1050 r = bus_kernel_connect(b);
1051 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1052 kdbus_available = true;
1054 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1055 if (!kdbus_available)
1056 r = bus_socket_connect(b);
1065 r = attach_io_events(b);
1070 b->last_connect_error = -r;
1073 r = bus_parse_next_address(b);
1077 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1081 int bus_next_address(sd_bus *b) {
1084 bus_reset_parsed_address(b);
1085 return bus_start_address(b);
1088 static int bus_start_fd(sd_bus *b) {
1093 assert(b->input_fd >= 0);
1094 assert(b->output_fd >= 0);
1096 r = fd_nonblock(b->input_fd, true);
1100 r = fd_cloexec(b->input_fd, true);
1104 if (b->input_fd != b->output_fd) {
1105 r = fd_nonblock(b->output_fd, true);
1109 r = fd_cloexec(b->output_fd, true);
1114 if (fstat(b->input_fd, &st) < 0)
1117 if (S_ISCHR(b->input_fd))
1118 return bus_kernel_take_fd(b);
1120 return bus_socket_take_fd(b);
1123 _public_ int sd_bus_start(sd_bus *bus) {
1126 assert_return(bus, -EINVAL);
1127 assert_return(bus->state == BUS_UNSET, -EPERM);
1128 assert_return(!bus_pid_changed(bus), -ECHILD);
1130 bus->state = BUS_OPENING;
1132 if (bus->is_server && bus->bus_client)
1135 if (bus->input_fd >= 0)
1136 r = bus_start_fd(bus);
1137 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1138 r = bus_start_address(bus);
1147 return bus_send_hello(bus);
1150 _public_ int sd_bus_open(sd_bus **ret) {
1155 assert_return(ret, -EINVAL);
1157 /* Let's connect to the starter bus if it is set, and
1158 * otherwise to the bus that is appropropriate for the scope
1159 * we are running in */
1161 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1163 if (streq(e, "system"))
1164 return sd_bus_open_system(ret);
1165 /// elogind does not support systemd units
1167 else if (STR_IN_SET(e, "session", "user"))
1168 return sd_bus_open_user(ret);
1172 e = secure_getenv("DBUS_STARTER_ADDRESS");
1174 /// elogind does not support systemd units
1176 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1177 return sd_bus_open_user(ret);
1180 return sd_bus_open_system(ret);
1187 r = sd_bus_set_address(b, e);
1191 b->bus_client = true;
1193 /* We don't know whether the bus is trusted or not, so better
1194 * be safe, and authenticate everything */
1196 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1197 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1199 r = sd_bus_start(b);
1211 int bus_set_address_system(sd_bus *b) {
1215 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1217 return sd_bus_set_address(b, e);
1219 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1222 _public_ int sd_bus_open_system(sd_bus **ret) {
1226 assert_return(ret, -EINVAL);
1232 r = bus_set_address_system(b);
1236 b->bus_client = true;
1237 b->is_system = true;
1239 /* Let's do per-method access control on the system bus. We
1240 * need the caller's UID and capability set for that. */
1242 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1243 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1245 r = sd_bus_start(b);
1257 /// elogind can not open/use a user bus
1259 int bus_set_address_user(sd_bus *b) {
1266 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1268 return sd_bus_set_address(b, e);
1270 r = cg_pid_get_owner_uid(0, &uid);
1274 e = secure_getenv("XDG_RUNTIME_DIR");
1276 _cleanup_free_ char *ee = NULL;
1278 ee = bus_address_escape(e);
1282 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1284 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1293 _public_ int sd_bus_open_user(sd_bus **ret) {
1294 /// elogind does not support user buses
1299 assert_return(ret, -EINVAL);
1305 r = bus_set_address_user(b);
1309 b->bus_client = true;
1312 /* We don't do any per-method access control on the user
1316 r = sd_bus_start(b);
1327 return sd_bus_open_system(ret);
1331 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1332 _cleanup_free_ char *e = NULL;
1333 char *m = NULL, *c = NULL;
1338 /* Let's see if we shall enter some container */
1339 m = strchr(host, ':');
1343 /* Let's make sure this is not a port of some kind,
1344 * and is a valid machine name. */
1345 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1348 /* Cut out the host part */
1349 t = strndupa(host, m - host - 1);
1350 e = bus_address_escape(t);
1354 c = strjoina(",argv4=--machine=", m);
1359 e = bus_address_escape(host);
1364 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1371 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1375 assert_return(host, -EINVAL);
1376 assert_return(ret, -EINVAL);
1378 r = sd_bus_new(&bus);
1382 r = bus_set_address_system_remote(bus, host);
1386 bus->bus_client = true;
1387 bus->trusted = false;
1388 bus->is_system = true;
1390 r = sd_bus_start(bus);
1402 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1403 _cleanup_free_ char *e = NULL;
1408 e = bus_address_escape(machine);
1412 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1419 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1423 assert_return(machine, -EINVAL);
1424 assert_return(ret, -EINVAL);
1425 assert_return(machine_name_is_valid(machine), -EINVAL);
1427 r = sd_bus_new(&bus);
1431 r = bus_set_address_system_machine(bus, machine);
1435 bus->bus_client = true;
1436 bus->trusted = false;
1437 bus->is_system = true;
1439 r = sd_bus_start(bus);
1451 _public_ void sd_bus_close(sd_bus *bus) {
1455 if (bus->state == BUS_CLOSED)
1457 if (bus_pid_changed(bus))
1460 bus->state = BUS_CLOSED;
1462 sd_bus_detach_event(bus);
1464 /* Drop all queued messages so that they drop references to
1465 * the bus object and the bus may be freed */
1466 bus_reset_queues(bus);
1468 if (!bus->is_kernel)
1471 /* We'll leave the fd open in case this is a kernel bus, since
1472 * there might still be memblocks around that reference this
1473 * bus, and they might need to invoke the KDBUS_CMD_FREE
1474 * ioctl on the fd when they are freed. */
1477 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1485 return sd_bus_unref(bus);
1488 static void bus_enter_closing(sd_bus *bus) {
1491 if (bus->state != BUS_OPENING &&
1492 bus->state != BUS_AUTHENTICATING &&
1493 bus->state != BUS_HELLO &&
1494 bus->state != BUS_RUNNING)
1497 bus->state = BUS_CLOSING;
1500 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1501 assert_return(bus, NULL);
1503 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1508 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1514 i = REFCNT_DEC(bus->n_ref);
1522 /// UNNEEDED by elogind
1524 _public_ int sd_bus_is_open(sd_bus *bus) {
1526 assert_return(bus, -EINVAL);
1527 assert_return(!bus_pid_changed(bus), -ECHILD);
1529 return BUS_IS_OPEN(bus->state);
1533 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1536 assert_return(bus, -EINVAL);
1537 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1538 assert_return(!bus_pid_changed(bus), -ECHILD);
1540 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1543 if (type == SD_BUS_TYPE_UNIX_FD) {
1544 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1547 r = bus_ensure_running(bus);
1551 return bus->can_fds;
1554 return bus_type_is_valid(type);
1557 /// UNNEEDED by elogind
1559 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1562 assert_return(bus, -EINVAL);
1563 assert_return(id, -EINVAL);
1564 assert_return(!bus_pid_changed(bus), -ECHILD);
1566 r = bus_ensure_running(bus);
1570 *id = bus->server_id;
1575 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1580 /* If we copy the same message to multiple
1581 * destinations, avoid using the same cookie
1583 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1588 timeout = BUS_DEFAULT_TIMEOUT;
1590 return bus_message_seal(m, ++b->cookie, timeout);
1593 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1594 bool remarshal = false;
1598 /* wrong packet version */
1599 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1602 /* wrong packet endianness */
1603 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1606 /* TODO: kdbus-messages received from the kernel contain data which is
1607 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1608 * force remarshaling of the message. Technically, we could just
1609 * recreate the kdbus message, but that is non-trivial as other parts of
1610 * the message refer to m->kdbus already. This should be fixed! */
1611 if ((*m)->kdbus && (*m)->release_kdbus)
1614 return remarshal ? bus_message_remarshal(b, m) : 0;
1617 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1621 /* Fake some timestamps, if they were requested, and not
1622 * already initialized */
1623 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1624 if (m->realtime <= 0)
1625 m->realtime = now(CLOCK_REALTIME);
1627 if (m->monotonic <= 0)
1628 m->monotonic = now(CLOCK_MONOTONIC);
1631 /* The bus specification says the serial number cannot be 0,
1632 * hence let's fill something in for synthetic messages. Since
1633 * synthetic messages might have a fake sender and we don't
1634 * want to interfere with the real sender's serial numbers we
1635 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1636 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1637 * even though kdbus can do 64bit. */
1638 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1641 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1648 r = bus_kernel_write_message(bus, m, hint_sync_call);
1650 r = bus_socket_write_message(bus, m, idx);
1655 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1656 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1657 bus_message_type_to_string(m->header->type),
1658 strna(sd_bus_message_get_sender(m)),
1659 strna(sd_bus_message_get_destination(m)),
1660 strna(sd_bus_message_get_path(m)),
1661 strna(sd_bus_message_get_interface(m)),
1662 strna(sd_bus_message_get_member(m)),
1663 BUS_MESSAGE_COOKIE(m),
1665 strna(m->error.message));
1670 static int dispatch_wqueue(sd_bus *bus) {
1674 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1676 while (bus->wqueue_size > 0) {
1678 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1682 /* Didn't do anything this time */
1684 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1685 /* Fully written. Let's drop the entry from
1688 * This isn't particularly optimized, but
1689 * well, this is supposed to be our worst-case
1690 * buffer only, and the socket buffer is
1691 * supposed to be our primary buffer, and if
1692 * it got full, then all bets are off
1695 bus->wqueue_size --;
1696 sd_bus_message_unref(bus->wqueue[0]);
1697 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1707 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1711 return bus_kernel_read_message(bus, hint_priority, priority);
1713 return bus_socket_read_message(bus);
1716 int bus_rqueue_make_room(sd_bus *bus) {
1719 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1722 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1728 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1733 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1735 /* Note that the priority logic is only available on kdbus,
1736 * where the rqueue is unused. We check the rqueue here
1737 * anyway, because it's simple... */
1740 if (bus->rqueue_size > 0) {
1741 /* Dispatch a queued message */
1743 *m = bus->rqueue[0];
1744 bus->rqueue_size --;
1745 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1749 /* Try to read a new message */
1750 r = bus_read_message(bus, hint_priority, priority);
1760 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1761 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1764 assert_return(m, -EINVAL);
1769 assert_return(!bus_pid_changed(bus), -ECHILD);
1770 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1772 if (!BUS_IS_OPEN(bus->state))
1776 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1783 /* If the cookie number isn't kept, then we know that no reply
1785 if (!cookie && !m->sealed)
1786 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1788 r = bus_seal_message(bus, m, 0);
1792 /* Remarshall if we have to. This will possibly unref the
1793 * message and place a replacement in m */
1794 r = bus_remarshal_message(bus, &m);
1798 /* If this is a reply and no reply was requested, then let's
1799 * suppress this, if we can */
1803 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1806 r = bus_write_message(bus, m, hint_sync_call, &idx);
1808 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1809 bus_enter_closing(bus);
1816 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1817 /* Wasn't fully written. So let's remember how
1818 * much was written. Note that the first entry
1819 * of the wqueue array is always allocated so
1820 * that we always can remember how much was
1822 bus->wqueue[0] = sd_bus_message_ref(m);
1823 bus->wqueue_size = 1;
1828 /* Just append it to the queue. */
1830 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1833 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1836 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1841 *cookie = BUS_MESSAGE_COOKIE(m);
1846 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1847 return bus_send_internal(bus, m, cookie, false);
1850 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1853 assert_return(m, -EINVAL);
1858 assert_return(!bus_pid_changed(bus), -ECHILD);
1860 if (!BUS_IS_OPEN(bus->state))
1863 if (!streq_ptr(m->destination, destination)) {
1868 r = sd_bus_message_set_destination(m, destination);
1873 return sd_bus_send(bus, m, cookie);
1876 static usec_t calc_elapse(uint64_t usec) {
1877 if (usec == (uint64_t) -1)
1880 return now(CLOCK_MONOTONIC) + usec;
1883 static int timeout_compare(const void *a, const void *b) {
1884 const struct reply_callback *x = a, *y = b;
1886 if (x->timeout != 0 && y->timeout == 0)
1889 if (x->timeout == 0 && y->timeout != 0)
1892 if (x->timeout < y->timeout)
1895 if (x->timeout > y->timeout)
1901 _public_ int sd_bus_call_async(
1905 sd_bus_message_handler_t callback,
1909 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1910 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1913 assert_return(m, -EINVAL);
1914 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1915 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1916 assert_return(callback, -EINVAL);
1921 assert_return(!bus_pid_changed(bus), -ECHILD);
1922 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1924 if (!BUS_IS_OPEN(bus->state))
1927 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1931 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1935 r = bus_seal_message(bus, m, usec);
1939 r = bus_remarshal_message(bus, &m);
1943 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1947 s->reply_callback.callback = callback;
1949 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1950 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1952 s->reply_callback.cookie = 0;
1956 s->reply_callback.timeout = calc_elapse(m->timeout);
1957 if (s->reply_callback.timeout != 0) {
1958 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1960 s->reply_callback.timeout = 0;
1965 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1976 int bus_ensure_running(sd_bus *bus) {
1981 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1983 if (bus->state == BUS_RUNNING)
1987 r = sd_bus_process(bus, NULL);
1990 if (bus->state == BUS_RUNNING)
1995 r = sd_bus_wait(bus, (uint64_t) -1);
2001 _public_ int sd_bus_call(
2005 sd_bus_error *error,
2006 sd_bus_message **reply) {
2008 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2014 bus_assert_return(m, -EINVAL, error);
2015 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2016 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2017 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2022 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2023 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2025 if (!BUS_IS_OPEN(bus->state)) {
2030 r = bus_ensure_running(bus);
2034 i = bus->rqueue_size;
2036 r = bus_seal_message(bus, m, usec);
2040 r = bus_remarshal_message(bus, &m);
2044 r = bus_send_internal(bus, m, &cookie, true);
2048 timeout = calc_elapse(m->timeout);
2053 while (i < bus->rqueue_size) {
2054 sd_bus_message *incoming = NULL;
2056 incoming = bus->rqueue[i];
2058 if (incoming->reply_cookie == cookie) {
2059 /* Found a match! */
2061 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2063 log_debug_bus_message(incoming);
2065 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2067 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2071 sd_bus_message_unref(incoming);
2076 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2077 sd_bus_message_unref(incoming);
2080 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2081 r = sd_bus_error_copy(error, &incoming->error);
2082 sd_bus_message_unref(incoming);
2089 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2092 streq(bus->unique_name, incoming->sender)) {
2094 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2097 /* Our own message? Somebody is trying
2098 * to send its own client a message,
2099 * let's not dead-lock, let's fail
2102 sd_bus_message_unref(incoming);
2107 /* Try to read more, right-away */
2111 r = bus_read_message(bus, false, 0);
2113 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2114 bus_enter_closing(bus);
2126 n = now(CLOCK_MONOTONIC);
2134 left = (uint64_t) -1;
2136 r = bus_poll(bus, true, left);
2144 r = dispatch_wqueue(bus);
2146 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2147 bus_enter_closing(bus);
2156 return sd_bus_error_set_errno(error, r);
2159 _public_ int sd_bus_get_fd(sd_bus *bus) {
2161 assert_return(bus, -EINVAL);
2162 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2163 assert_return(!bus_pid_changed(bus), -ECHILD);
2165 return bus->input_fd;
2168 _public_ int sd_bus_get_events(sd_bus *bus) {
2171 assert_return(bus, -EINVAL);
2172 assert_return(!bus_pid_changed(bus), -ECHILD);
2174 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2177 if (bus->state == BUS_OPENING)
2179 else if (bus->state == BUS_AUTHENTICATING) {
2181 if (bus_socket_auth_needs_write(bus))
2186 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2187 if (bus->rqueue_size <= 0)
2189 if (bus->wqueue_size > 0)
2196 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2197 struct reply_callback *c;
2199 assert_return(bus, -EINVAL);
2200 assert_return(timeout_usec, -EINVAL);
2201 assert_return(!bus_pid_changed(bus), -ECHILD);
2203 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2206 if (bus->track_queue) {
2211 if (bus->state == BUS_CLOSING) {
2216 if (bus->state == BUS_AUTHENTICATING) {
2217 *timeout_usec = bus->auth_timeout;
2221 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2222 *timeout_usec = (uint64_t) -1;
2226 if (bus->rqueue_size > 0) {
2231 c = prioq_peek(bus->reply_callbacks_prioq);
2233 *timeout_usec = (uint64_t) -1;
2237 if (c->timeout == 0) {
2238 *timeout_usec = (uint64_t) -1;
2242 *timeout_usec = c->timeout;
2246 static int process_timeout(sd_bus *bus) {
2247 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2248 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2249 struct reply_callback *c;
2256 c = prioq_peek(bus->reply_callbacks_prioq);
2260 n = now(CLOCK_MONOTONIC);
2264 r = bus_message_new_synthetic_error(
2267 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2272 r = bus_seal_synthetic_message(bus, m);
2276 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2279 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2282 slot = container_of(c, sd_bus_slot, reply_callback);
2284 bus->iteration_counter ++;
2286 bus->current_message = m;
2287 bus->current_slot = sd_bus_slot_ref(slot);
2288 bus->current_handler = c->callback;
2289 bus->current_userdata = slot->userdata;
2290 r = c->callback(m, slot->userdata, &error_buffer);
2291 bus->current_userdata = NULL;
2292 bus->current_handler = NULL;
2293 bus->current_slot = NULL;
2294 bus->current_message = NULL;
2296 if (slot->floating) {
2297 bus_slot_disconnect(slot);
2298 sd_bus_slot_unref(slot);
2301 sd_bus_slot_unref(slot);
2303 return bus_maybe_reply_error(m, r, &error_buffer);
2306 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2310 if (bus->state != BUS_HELLO)
2313 /* Let's make sure the first message on the bus is the HELLO
2314 * reply. But note that we don't actually parse the message
2315 * here (we leave that to the usual handling), we just verify
2316 * we don't let any earlier msg through. */
2318 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2319 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2322 if (m->reply_cookie != 1)
2328 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2329 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2330 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2331 struct reply_callback *c;
2338 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2339 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2342 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2345 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2348 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2354 slot = container_of(c, sd_bus_slot, reply_callback);
2356 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2358 /* If the reply contained a file descriptor which we
2359 * didn't want we pass an error instead. */
2361 r = bus_message_new_synthetic_error(
2364 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2369 /* Copy over original timestamp */
2370 synthetic_reply->realtime = m->realtime;
2371 synthetic_reply->monotonic = m->monotonic;
2372 synthetic_reply->seqnum = m->seqnum;
2374 r = bus_seal_synthetic_message(bus, synthetic_reply);
2378 m = synthetic_reply;
2380 r = sd_bus_message_rewind(m, true);
2385 if (c->timeout != 0) {
2386 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2390 bus->current_slot = sd_bus_slot_ref(slot);
2391 bus->current_handler = c->callback;
2392 bus->current_userdata = slot->userdata;
2393 r = c->callback(m, slot->userdata, &error_buffer);
2394 bus->current_userdata = NULL;
2395 bus->current_handler = NULL;
2396 bus->current_slot = NULL;
2398 if (slot->floating) {
2399 bus_slot_disconnect(slot);
2400 sd_bus_slot_unref(slot);
2403 sd_bus_slot_unref(slot);
2405 return bus_maybe_reply_error(m, r, &error_buffer);
2408 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2409 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2410 struct filter_callback *l;
2417 bus->filter_callbacks_modified = false;
2419 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2422 if (bus->filter_callbacks_modified)
2425 /* Don't run this more than once per iteration */
2426 if (l->last_iteration == bus->iteration_counter)
2429 l->last_iteration = bus->iteration_counter;
2431 r = sd_bus_message_rewind(m, true);
2435 slot = container_of(l, sd_bus_slot, filter_callback);
2437 bus->current_slot = sd_bus_slot_ref(slot);
2438 bus->current_handler = l->callback;
2439 bus->current_userdata = slot->userdata;
2440 r = l->callback(m, slot->userdata, &error_buffer);
2441 bus->current_userdata = NULL;
2442 bus->current_handler = NULL;
2443 bus->current_slot = sd_bus_slot_unref(slot);
2445 r = bus_maybe_reply_error(m, r, &error_buffer);
2451 } while (bus->filter_callbacks_modified);
2456 static int process_match(sd_bus *bus, sd_bus_message *m) {
2463 bus->match_callbacks_modified = false;
2465 r = bus_match_run(bus, &bus->match_callbacks, m);
2469 } while (bus->match_callbacks_modified);
2474 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2475 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2481 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2484 if (bus->manual_peer_interface)
2487 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2490 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2493 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2496 if (streq_ptr(m->member, "Ping"))
2497 r = sd_bus_message_new_method_return(m, &reply);
2498 else if (streq_ptr(m->member, "GetMachineId")) {
2502 r = sd_id128_get_machine(&id);
2506 r = sd_bus_message_new_method_return(m, &reply);
2510 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2512 r = sd_bus_message_new_method_errorf(
2514 SD_BUS_ERROR_UNKNOWN_METHOD,
2515 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2521 r = sd_bus_send(bus, reply, NULL);
2528 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2532 /* If we got a message with a file descriptor which we didn't
2533 * want to accept, then let's drop it. How can this even
2534 * happen? For example, when the kernel queues a message into
2535 * an activatable names's queue which allows fds, and then is
2536 * delivered to us later even though we ourselves did not
2539 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2545 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2548 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2549 return 1; /* just eat it up */
2551 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2554 static int process_message(sd_bus *bus, sd_bus_message *m) {
2560 bus->current_message = m;
2561 bus->iteration_counter++;
2563 log_debug_bus_message(m);
2565 r = process_hello(bus, m);
2569 r = process_reply(bus, m);
2573 r = process_fd_check(bus, m);
2577 r = process_filter(bus, m);
2581 r = process_match(bus, m);
2585 r = process_builtin(bus, m);
2589 r = bus_process_object(bus, m);
2592 bus->current_message = NULL;
2596 static int dispatch_track(sd_bus *bus) {
2599 if (!bus->track_queue)
2602 bus_track_dispatch(bus->track_queue);
2606 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2607 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2611 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2613 r = process_timeout(bus);
2617 r = dispatch_wqueue(bus);
2621 r = dispatch_track(bus);
2625 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2631 r = process_message(bus, m);
2636 r = sd_bus_message_rewind(m, true);
2645 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2647 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2648 strna(sd_bus_message_get_sender(m)),
2649 strna(sd_bus_message_get_path(m)),
2650 strna(sd_bus_message_get_interface(m)),
2651 strna(sd_bus_message_get_member(m)));
2653 r = sd_bus_reply_method_errorf(
2655 SD_BUS_ERROR_UNKNOWN_OBJECT,
2656 "Unknown object '%s'.", m->path);
2670 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2671 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2672 struct reply_callback *c;
2676 assert(bus->state == BUS_CLOSING);
2678 c = ordered_hashmap_first(bus->reply_callbacks);
2680 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2683 /* First, fail all outstanding method calls */
2684 r = bus_message_new_synthetic_error(
2687 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2692 r = bus_seal_synthetic_message(bus, m);
2696 if (c->timeout != 0) {
2697 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2701 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2704 slot = container_of(c, sd_bus_slot, reply_callback);
2706 bus->iteration_counter++;
2708 bus->current_message = m;
2709 bus->current_slot = sd_bus_slot_ref(slot);
2710 bus->current_handler = c->callback;
2711 bus->current_userdata = slot->userdata;
2712 r = c->callback(m, slot->userdata, &error_buffer);
2713 bus->current_userdata = NULL;
2714 bus->current_handler = NULL;
2715 bus->current_slot = NULL;
2716 bus->current_message = NULL;
2718 if (slot->floating) {
2719 bus_slot_disconnect(slot);
2720 sd_bus_slot_unref(slot);
2723 sd_bus_slot_unref(slot);
2725 return bus_maybe_reply_error(m, r, &error_buffer);
2728 /* Then, synthesize a Disconnected message */
2729 r = sd_bus_message_new_signal(
2732 "/org/freedesktop/DBus/Local",
2733 "org.freedesktop.DBus.Local",
2738 bus_message_set_sender_local(bus, m);
2740 r = bus_seal_synthetic_message(bus, m);
2746 bus->current_message = m;
2747 bus->iteration_counter++;
2749 r = process_filter(bus, m);
2753 r = process_match(bus, m);
2765 bus->current_message = NULL;
2770 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2771 BUS_DONT_DESTROY(bus);
2774 /* Returns 0 when we didn't do anything. This should cause the
2775 * caller to invoke sd_bus_wait() before returning the next
2776 * time. Returns > 0 when we did something, which possibly
2777 * means *ret is filled in with an unprocessed message. */
2779 assert_return(bus, -EINVAL);
2780 assert_return(!bus_pid_changed(bus), -ECHILD);
2782 /* We don't allow recursively invoking sd_bus_process(). */
2783 assert_return(!bus->current_message, -EBUSY);
2784 assert(!bus->current_slot);
2786 switch (bus->state) {
2795 r = bus_socket_process_opening(bus);
2796 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2797 bus_enter_closing(bus);
2805 case BUS_AUTHENTICATING:
2806 r = bus_socket_process_authenticating(bus);
2807 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2808 bus_enter_closing(bus);
2820 r = process_running(bus, hint_priority, priority, ret);
2821 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2822 bus_enter_closing(bus);
2832 return process_closing(bus, ret);
2835 assert_not_reached("Unknown state");
2838 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2839 return bus_process_internal(bus, false, 0, ret);
2842 /// UNNEEDED by elogind
2844 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2845 return bus_process_internal(bus, true, priority, ret);
2849 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2850 struct pollfd p[2] = {};
2853 usec_t m = USEC_INFINITY;
2857 if (bus->state == BUS_CLOSING)
2860 if (!BUS_IS_OPEN(bus->state))
2863 e = sd_bus_get_events(bus);
2868 /* The caller really needs some more data, he doesn't
2869 * care about what's already read, or any timeouts
2870 * except its own. */
2874 /* The caller wants to process if there's something to
2875 * process, but doesn't care otherwise */
2877 r = sd_bus_get_timeout(bus, &until);
2882 nw = now(CLOCK_MONOTONIC);
2883 m = until > nw ? until - nw : 0;
2887 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2890 p[0].fd = bus->input_fd;
2891 if (bus->output_fd == bus->input_fd) {
2895 p[0].events = e & POLLIN;
2896 p[1].fd = bus->output_fd;
2897 p[1].events = e & POLLOUT;
2901 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2905 return r > 0 ? 1 : 0;
2908 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2910 assert_return(bus, -EINVAL);
2911 assert_return(!bus_pid_changed(bus), -ECHILD);
2913 if (bus->state == BUS_CLOSING)
2916 if (!BUS_IS_OPEN(bus->state))
2919 if (bus->rqueue_size > 0)
2922 return bus_poll(bus, false, timeout_usec);
2925 _public_ int sd_bus_flush(sd_bus *bus) {
2928 assert_return(bus, -EINVAL);
2929 assert_return(!bus_pid_changed(bus), -ECHILD);
2931 if (bus->state == BUS_CLOSING)
2934 if (!BUS_IS_OPEN(bus->state))
2937 r = bus_ensure_running(bus);
2941 if (bus->wqueue_size <= 0)
2945 r = dispatch_wqueue(bus);
2947 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2948 bus_enter_closing(bus);
2955 if (bus->wqueue_size <= 0)
2958 r = bus_poll(bus, false, (uint64_t) -1);
2964 _public_ int sd_bus_add_filter(
2967 sd_bus_message_handler_t callback,
2972 assert_return(bus, -EINVAL);
2973 assert_return(callback, -EINVAL);
2974 assert_return(!bus_pid_changed(bus), -ECHILD);
2976 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2980 s->filter_callback.callback = callback;
2982 bus->filter_callbacks_modified = true;
2983 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2991 _public_ int sd_bus_add_match(
2995 sd_bus_message_handler_t callback,
2998 struct bus_match_component *components = NULL;
2999 unsigned n_components = 0;
3000 sd_bus_slot *s = NULL;
3003 assert_return(bus, -EINVAL);
3004 assert_return(match, -EINVAL);
3005 assert_return(!bus_pid_changed(bus), -ECHILD);
3007 r = bus_match_parse(match, &components, &n_components);
3011 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3017 s->match_callback.callback = callback;
3018 s->match_callback.cookie = ++bus->match_cookie;
3020 if (bus->bus_client) {
3021 enum bus_match_scope scope;
3023 scope = bus_match_get_scope(components, n_components);
3025 /* Do not install server-side matches for matches
3026 * against the local service, interface or bus
3028 if (scope != BUS_MATCH_LOCAL) {
3030 if (!bus->is_kernel) {
3031 /* When this is not a kernel transport, we
3032 * store the original match string, so that we
3033 * can use it to remove the match again */
3035 s->match_callback.match_string = strdup(match);
3036 if (!s->match_callback.match_string) {
3042 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3046 s->match_added = true;
3050 bus->match_callbacks_modified = true;
3051 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3060 bus_match_parse_free(components, n_components);
3061 sd_bus_slot_unref(s);
3066 /// UNNEEDED by elogind
3068 int bus_remove_match_by_string(
3071 sd_bus_message_handler_t callback,
3074 struct bus_match_component *components = NULL;
3075 unsigned n_components = 0;
3076 struct match_callback *c;
3079 assert_return(bus, -EINVAL);
3080 assert_return(match, -EINVAL);
3081 assert_return(!bus_pid_changed(bus), -ECHILD);
3083 r = bus_match_parse(match, &components, &n_components);
3087 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3091 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3094 bus_match_parse_free(components, n_components);
3100 bool bus_pid_changed(sd_bus *bus) {
3103 /* We don't support people creating a bus connection and
3104 * keeping it around over a fork(). Let's complain. */
3106 return bus->original_pid != getpid();
3109 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3110 sd_bus *bus = userdata;
3115 r = sd_bus_process(bus, NULL);
3122 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3123 sd_bus *bus = userdata;
3128 r = sd_bus_process(bus, NULL);
3135 static int prepare_callback(sd_event_source *s, void *userdata) {
3136 sd_bus *bus = userdata;
3143 e = sd_bus_get_events(bus);
3147 if (bus->output_fd != bus->input_fd) {
3149 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3153 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3157 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3162 r = sd_bus_get_timeout(bus, &until);
3168 j = sd_event_source_set_time(bus->time_event_source, until);
3173 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3180 static int quit_callback(sd_event_source *event, void *userdata) {
3181 sd_bus *bus = userdata;
3191 static int attach_io_events(sd_bus *bus) {
3196 if (bus->input_fd < 0)
3202 if (!bus->input_io_event_source) {
3203 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3207 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3211 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3215 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3217 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3222 if (bus->output_fd != bus->input_fd) {
3223 assert(bus->output_fd >= 0);
3225 if (!bus->output_io_event_source) {
3226 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3230 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3234 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3236 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3245 static void detach_io_events(sd_bus *bus) {
3248 if (bus->input_io_event_source) {
3249 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3250 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3253 if (bus->output_io_event_source) {
3254 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3255 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3259 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3262 assert_return(bus, -EINVAL);
3263 assert_return(!bus->event, -EBUSY);
3265 assert(!bus->input_io_event_source);
3266 assert(!bus->output_io_event_source);
3267 assert(!bus->time_event_source);
3270 bus->event = sd_event_ref(event);
3272 r = sd_event_default(&bus->event);
3277 bus->event_priority = priority;
3279 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3283 r = sd_event_source_set_priority(bus->time_event_source, priority);
3287 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3291 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3295 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3299 r = attach_io_events(bus);
3306 sd_bus_detach_event(bus);
3310 _public_ int sd_bus_detach_event(sd_bus *bus) {
3311 assert_return(bus, -EINVAL);
3316 detach_io_events(bus);
3318 if (bus->time_event_source) {
3319 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3320 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3323 if (bus->quit_event_source) {
3324 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3325 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3328 bus->event = sd_event_unref(bus->event);
3332 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3333 assert_return(bus, NULL);
3338 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3339 assert_return(bus, NULL);
3341 return bus->current_message;
3344 /// UNNEEDED by elogind
3346 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3347 assert_return(bus, NULL);
3349 return bus->current_slot;
3353 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3354 assert_return(bus, NULL);
3356 return bus->current_handler;
3359 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3360 assert_return(bus, NULL);
3362 return bus->current_userdata;
3365 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3370 assert(default_bus);
3373 return !!*default_bus;
3376 *ret = sd_bus_ref(*default_bus);
3384 b->default_bus_ptr = default_bus;
3392 _public_ int sd_bus_default_system(sd_bus **ret) {
3393 static thread_local sd_bus *default_system_bus = NULL;
3395 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3398 _public_ int sd_bus_default_user(sd_bus **ret) {
3399 /// elogind does not support user buses
3401 static thread_local sd_bus *default_user_bus = NULL;
3403 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3405 return sd_bus_default_system(ret);
3409 _public_ int sd_bus_default(sd_bus **ret) {
3413 /* Let's try our best to reuse another cached connection. If
3414 * the starter bus type is set, connect via our normal
3415 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3416 * we can share the connection with the user/system default
3419 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3421 if (streq(e, "system"))
3422 return sd_bus_default_system(ret);
3423 /// elogind does not support systemd units
3425 else if (STR_IN_SET(e, "user", "session"))
3426 return sd_bus_default_user(ret);
3430 /* No type is specified, so we have not other option than to
3431 * use the starter address if it is set. */
3433 e = secure_getenv("DBUS_STARTER_ADDRESS");
3435 static thread_local sd_bus *default_starter_bus = NULL;
3437 return bus_default(sd_bus_open, &default_starter_bus, ret);
3440 /* Finally, if nothing is set use the cached connection for
3441 * the right scope */
3442 /// elogind does not support systemd units
3444 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3445 return sd_bus_default_user(ret);
3448 return sd_bus_default_system(ret);
3451 /// UNNEEDED by elogind
3453 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3454 assert_return(b, -EINVAL);
3455 assert_return(tid, -EINVAL);
3456 assert_return(!bus_pid_changed(b), -ECHILD);
3464 return sd_event_get_tid(b->event, tid);
3469 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3470 _cleanup_free_ char *e = NULL;
3473 assert_return(object_path_is_valid(prefix), -EINVAL);
3474 assert_return(external_id, -EINVAL);
3475 assert_return(ret_path, -EINVAL);
3477 e = bus_label_escape(external_id);
3481 ret = strjoin(prefix, "/", e, NULL);
3489 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3493 assert_return(object_path_is_valid(path), -EINVAL);
3494 assert_return(object_path_is_valid(prefix), -EINVAL);
3495 assert_return(external_id, -EINVAL);
3497 e = object_path_startswith(path, prefix);
3499 *external_id = NULL;
3503 ret = bus_label_unescape(e);
3512 _public_ int sd_bus_try_close(sd_bus *bus) {
3515 assert_return(bus, -EINVAL);
3516 assert_return(!bus_pid_changed(bus), -ECHILD);
3518 if (!bus->is_kernel)
3521 if (!BUS_IS_OPEN(bus->state))
3524 if (bus->rqueue_size > 0)
3527 if (bus->wqueue_size > 0)
3530 r = bus_kernel_try_close(bus);
3538 /// UNNEEDED by elogind
3540 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3541 assert_return(bus, -EINVAL);
3542 assert_return(description, -EINVAL);
3543 assert_return(bus->description, -ENXIO);
3544 assert_return(!bus_pid_changed(bus), -ECHILD);
3546 *description = bus->description;
3551 int bus_get_root_path(sd_bus *bus) {
3554 if (bus->cgroup_root)
3557 r = cg_get_root_path(&bus->cgroup_root);
3559 bus->cgroup_root = strdup("/");
3560 if (!bus->cgroup_root)
3569 /// UNNEEDED by elogind
3571 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3574 assert_return(bus, -EINVAL);
3575 assert_return(scope, -EINVAL);
3576 assert_return(!bus_pid_changed(bus), -ECHILD);
3578 if (bus->is_kernel) {
3579 _cleanup_free_ char *n = NULL;
3582 r = bus_kernel_get_bus_name(bus, &n);
3586 if (streq(n, "0-system")) {
3591 dash = strchr(n, '-');
3592 if (streq_ptr(dash, "-user")) {
3603 if (bus->is_system) {
3611 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3613 assert_return(bus, -EINVAL);
3614 assert_return(address, -EINVAL);
3615 assert_return(!bus_pid_changed(bus), -ECHILD);
3618 *address = bus->address;
3625 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3626 assert_return(bus, -EINVAL);
3627 assert_return(mask, -EINVAL);
3628 assert_return(!bus_pid_changed(bus), -ECHILD);
3630 *mask = bus->creds_mask;
3634 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3635 assert_return(bus, -EINVAL);
3636 assert_return(!bus_pid_changed(bus), -ECHILD);
3638 return bus->bus_client;
3641 _public_ int sd_bus_is_server(sd_bus *bus) {
3642 assert_return(bus, -EINVAL);
3643 assert_return(!bus_pid_changed(bus), -ECHILD);
3645 return bus->is_server;
3648 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3649 assert_return(bus, -EINVAL);
3650 assert_return(!bus_pid_changed(bus), -ECHILD);
3652 return bus->anonymous_auth;
3655 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3656 assert_return(bus, -EINVAL);
3657 assert_return(!bus_pid_changed(bus), -ECHILD);
3659 return bus->trusted;
3662 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3663 assert_return(bus, -EINVAL);
3664 assert_return(!bus_pid_changed(bus), -ECHILD);
3666 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);