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;
832 b->machine = mfree(b->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;
891 b->machine = mfree(b->machine);
895 r = parse_pid(pid, &b->nspid);
901 r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
908 static void bus_reset_parsed_address(sd_bus *b) {
912 b->sockaddr_size = 0;
913 b->exec_argv = strv_free(b->exec_argv);
914 b->exec_path = mfree(b->exec_path);
915 b->server_id = SD_ID128_NULL;
916 b->kernel = mfree(b->kernel);
917 b->machine = mfree(b->machine);
921 static int bus_parse_next_address(sd_bus *b) {
922 _cleanup_free_ char *guid = NULL;
930 if (b->address[b->address_index] == 0)
933 bus_reset_parsed_address(b);
935 a = b->address + b->address_index;
944 if (startswith(a, "unix:")) {
947 r = parse_unix_address(b, &a, &guid);
952 } else if (startswith(a, "tcp:")) {
955 r = parse_tcp_address(b, &a, &guid);
961 } else if (startswith(a, "unixexec:")) {
964 r = parse_exec_address(b, &a, &guid);
970 } else if (startswith(a, "kernel:")) {
973 r = parse_kernel_address(b, &a, &guid);
978 } else if (startswith(a, "x-machine-unix:")) {
981 r = parse_container_unix_address(b, &a, &guid);
986 } else if (startswith(a, "x-machine-kernel:")) {
989 r = parse_container_kernel_address(b, &a, &guid);
1002 r = sd_id128_from_string(guid, &b->server_id);
1007 b->address_index = a - b->address;
1011 static int bus_start_address(sd_bus *b) {
1012 bool container_kdbus_available = false;
1013 bool kdbus_available = false;
1019 bool skipped = false;
1024 * Usually, if you provide multiple different bus-addresses, we
1025 * try all of them in order. We use the first one that
1026 * succeeds. However, if you mix kernel and unix addresses, we
1027 * never try unix-addresses if a previous kernel address was
1028 * tried and kdbus was available. This is required to prevent
1029 * clients to fallback to the bus-proxy if kdbus is available
1030 * but failed (eg., too many connections).
1034 r = bus_socket_exec(b);
1036 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1037 r = bus_container_connect_kernel(b);
1038 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1039 container_kdbus_available = true;
1041 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1042 if (!container_kdbus_available)
1043 r = bus_container_connect_socket(b);
1047 } else if (b->kernel) {
1048 r = bus_kernel_connect(b);
1049 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1050 kdbus_available = true;
1052 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1053 if (!kdbus_available)
1054 r = bus_socket_connect(b);
1063 r = attach_io_events(b);
1068 b->last_connect_error = -r;
1071 r = bus_parse_next_address(b);
1075 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1079 int bus_next_address(sd_bus *b) {
1082 bus_reset_parsed_address(b);
1083 return bus_start_address(b);
1086 static int bus_start_fd(sd_bus *b) {
1091 assert(b->input_fd >= 0);
1092 assert(b->output_fd >= 0);
1094 r = fd_nonblock(b->input_fd, true);
1098 r = fd_cloexec(b->input_fd, true);
1102 if (b->input_fd != b->output_fd) {
1103 r = fd_nonblock(b->output_fd, true);
1107 r = fd_cloexec(b->output_fd, true);
1112 if (fstat(b->input_fd, &st) < 0)
1115 if (S_ISCHR(b->input_fd))
1116 return bus_kernel_take_fd(b);
1118 return bus_socket_take_fd(b);
1121 _public_ int sd_bus_start(sd_bus *bus) {
1124 assert_return(bus, -EINVAL);
1125 assert_return(bus->state == BUS_UNSET, -EPERM);
1126 assert_return(!bus_pid_changed(bus), -ECHILD);
1128 bus->state = BUS_OPENING;
1130 if (bus->is_server && bus->bus_client)
1133 if (bus->input_fd >= 0)
1134 r = bus_start_fd(bus);
1135 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1136 r = bus_start_address(bus);
1145 return bus_send_hello(bus);
1148 _public_ int sd_bus_open(sd_bus **ret) {
1153 assert_return(ret, -EINVAL);
1155 /* Let's connect to the starter bus if it is set, and
1156 * otherwise to the bus that is appropropriate for the scope
1157 * we are running in */
1159 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1161 if (streq(e, "system"))
1162 return sd_bus_open_system(ret);
1163 /// elogind does not support systemd units
1165 else if (STR_IN_SET(e, "session", "user"))
1166 return sd_bus_open_user(ret);
1170 e = secure_getenv("DBUS_STARTER_ADDRESS");
1172 /// elogind does not support systemd units
1174 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1175 return sd_bus_open_user(ret);
1178 return sd_bus_open_system(ret);
1185 r = sd_bus_set_address(b, e);
1189 b->bus_client = true;
1191 /* We don't know whether the bus is trusted or not, so better
1192 * be safe, and authenticate everything */
1194 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1195 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1197 r = sd_bus_start(b);
1209 int bus_set_address_system(sd_bus *b) {
1213 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1215 return sd_bus_set_address(b, e);
1217 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1220 _public_ int sd_bus_open_system(sd_bus **ret) {
1224 assert_return(ret, -EINVAL);
1230 r = bus_set_address_system(b);
1234 b->bus_client = true;
1235 b->is_system = true;
1237 /* Let's do per-method access control on the system bus. We
1238 * need the caller's UID and capability set for that. */
1240 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1241 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1243 r = sd_bus_start(b);
1255 /// elogind can not open/use a user bus
1257 int bus_set_address_user(sd_bus *b) {
1264 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1266 return sd_bus_set_address(b, e);
1268 r = cg_pid_get_owner_uid(0, &uid);
1272 e = secure_getenv("XDG_RUNTIME_DIR");
1274 _cleanup_free_ char *ee = NULL;
1276 ee = bus_address_escape(e);
1280 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1282 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1291 _public_ int sd_bus_open_user(sd_bus **ret) {
1292 /// elogind does not support user buses
1297 assert_return(ret, -EINVAL);
1303 r = bus_set_address_user(b);
1307 b->bus_client = true;
1310 /* We don't do any per-method access control on the user
1314 r = sd_bus_start(b);
1325 return sd_bus_open_system(ret);
1329 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1330 _cleanup_free_ char *e = NULL;
1331 char *m = NULL, *c = NULL;
1336 /* Let's see if we shall enter some container */
1337 m = strchr(host, ':');
1341 /* Let's make sure this is not a port of some kind,
1342 * and is a valid machine name. */
1343 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1346 /* Cut out the host part */
1347 t = strndupa(host, m - host - 1);
1348 e = bus_address_escape(t);
1352 c = strjoina(",argv4=--machine=", m);
1357 e = bus_address_escape(host);
1362 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1369 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1373 assert_return(host, -EINVAL);
1374 assert_return(ret, -EINVAL);
1376 r = sd_bus_new(&bus);
1380 r = bus_set_address_system_remote(bus, host);
1384 bus->bus_client = true;
1385 bus->trusted = false;
1386 bus->is_system = true;
1388 r = sd_bus_start(bus);
1400 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1401 _cleanup_free_ char *e = NULL;
1406 e = bus_address_escape(machine);
1410 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1417 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1421 assert_return(machine, -EINVAL);
1422 assert_return(ret, -EINVAL);
1423 assert_return(machine_name_is_valid(machine), -EINVAL);
1425 r = sd_bus_new(&bus);
1429 r = bus_set_address_system_machine(bus, machine);
1433 bus->bus_client = true;
1434 bus->trusted = false;
1435 bus->is_system = true;
1437 r = sd_bus_start(bus);
1449 _public_ void sd_bus_close(sd_bus *bus) {
1453 if (bus->state == BUS_CLOSED)
1455 if (bus_pid_changed(bus))
1458 bus->state = BUS_CLOSED;
1460 sd_bus_detach_event(bus);
1462 /* Drop all queued messages so that they drop references to
1463 * the bus object and the bus may be freed */
1464 bus_reset_queues(bus);
1466 if (!bus->is_kernel)
1469 /* We'll leave the fd open in case this is a kernel bus, since
1470 * there might still be memblocks around that reference this
1471 * bus, and they might need to invoke the KDBUS_CMD_FREE
1472 * ioctl on the fd when they are freed. */
1475 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1483 return sd_bus_unref(bus);
1486 static void bus_enter_closing(sd_bus *bus) {
1489 if (bus->state != BUS_OPENING &&
1490 bus->state != BUS_AUTHENTICATING &&
1491 bus->state != BUS_HELLO &&
1492 bus->state != BUS_RUNNING)
1495 bus->state = BUS_CLOSING;
1498 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1499 assert_return(bus, NULL);
1501 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1506 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1512 i = REFCNT_DEC(bus->n_ref);
1520 /// UNNEEDED by elogind
1522 _public_ int sd_bus_is_open(sd_bus *bus) {
1524 assert_return(bus, -EINVAL);
1525 assert_return(!bus_pid_changed(bus), -ECHILD);
1527 return BUS_IS_OPEN(bus->state);
1531 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1534 assert_return(bus, -EINVAL);
1535 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1536 assert_return(!bus_pid_changed(bus), -ECHILD);
1538 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1541 if (type == SD_BUS_TYPE_UNIX_FD) {
1542 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1545 r = bus_ensure_running(bus);
1549 return bus->can_fds;
1552 return bus_type_is_valid(type);
1555 /// UNNEEDED by elogind
1557 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1560 assert_return(bus, -EINVAL);
1561 assert_return(id, -EINVAL);
1562 assert_return(!bus_pid_changed(bus), -ECHILD);
1564 r = bus_ensure_running(bus);
1568 *id = bus->server_id;
1573 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1578 /* If we copy the same message to multiple
1579 * destinations, avoid using the same cookie
1581 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1586 timeout = BUS_DEFAULT_TIMEOUT;
1588 return bus_message_seal(m, ++b->cookie, timeout);
1591 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1592 bool remarshal = false;
1596 /* wrong packet version */
1597 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1600 /* wrong packet endianness */
1601 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1604 /* TODO: kdbus-messages received from the kernel contain data which is
1605 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1606 * force remarshaling of the message. Technically, we could just
1607 * recreate the kdbus message, but that is non-trivial as other parts of
1608 * the message refer to m->kdbus already. This should be fixed! */
1609 if ((*m)->kdbus && (*m)->release_kdbus)
1612 return remarshal ? bus_message_remarshal(b, m) : 0;
1615 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1619 /* Fake some timestamps, if they were requested, and not
1620 * already initialized */
1621 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1622 if (m->realtime <= 0)
1623 m->realtime = now(CLOCK_REALTIME);
1625 if (m->monotonic <= 0)
1626 m->monotonic = now(CLOCK_MONOTONIC);
1629 /* The bus specification says the serial number cannot be 0,
1630 * hence let's fill something in for synthetic messages. Since
1631 * synthetic messages might have a fake sender and we don't
1632 * want to interfere with the real sender's serial numbers we
1633 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1634 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1635 * even though kdbus can do 64bit. */
1636 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1639 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1646 r = bus_kernel_write_message(bus, m, hint_sync_call);
1648 r = bus_socket_write_message(bus, m, idx);
1653 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1654 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1655 bus_message_type_to_string(m->header->type),
1656 strna(sd_bus_message_get_sender(m)),
1657 strna(sd_bus_message_get_destination(m)),
1658 strna(sd_bus_message_get_path(m)),
1659 strna(sd_bus_message_get_interface(m)),
1660 strna(sd_bus_message_get_member(m)),
1661 BUS_MESSAGE_COOKIE(m),
1663 strna(m->error.message));
1668 static int dispatch_wqueue(sd_bus *bus) {
1672 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1674 while (bus->wqueue_size > 0) {
1676 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1680 /* Didn't do anything this time */
1682 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1683 /* Fully written. Let's drop the entry from
1686 * This isn't particularly optimized, but
1687 * well, this is supposed to be our worst-case
1688 * buffer only, and the socket buffer is
1689 * supposed to be our primary buffer, and if
1690 * it got full, then all bets are off
1693 bus->wqueue_size --;
1694 sd_bus_message_unref(bus->wqueue[0]);
1695 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1705 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1709 return bus_kernel_read_message(bus, hint_priority, priority);
1711 return bus_socket_read_message(bus);
1714 int bus_rqueue_make_room(sd_bus *bus) {
1717 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1720 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1726 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1731 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1733 /* Note that the priority logic is only available on kdbus,
1734 * where the rqueue is unused. We check the rqueue here
1735 * anyway, because it's simple... */
1738 if (bus->rqueue_size > 0) {
1739 /* Dispatch a queued message */
1741 *m = bus->rqueue[0];
1742 bus->rqueue_size --;
1743 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1747 /* Try to read a new message */
1748 r = bus_read_message(bus, hint_priority, priority);
1758 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1759 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1762 assert_return(m, -EINVAL);
1767 assert_return(!bus_pid_changed(bus), -ECHILD);
1768 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1770 if (!BUS_IS_OPEN(bus->state))
1774 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1781 /* If the cookie number isn't kept, then we know that no reply
1783 if (!cookie && !m->sealed)
1784 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1786 r = bus_seal_message(bus, m, 0);
1790 /* Remarshall if we have to. This will possibly unref the
1791 * message and place a replacement in m */
1792 r = bus_remarshal_message(bus, &m);
1796 /* If this is a reply and no reply was requested, then let's
1797 * suppress this, if we can */
1801 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1804 r = bus_write_message(bus, m, hint_sync_call, &idx);
1806 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1807 bus_enter_closing(bus);
1814 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1815 /* Wasn't fully written. So let's remember how
1816 * much was written. Note that the first entry
1817 * of the wqueue array is always allocated so
1818 * that we always can remember how much was
1820 bus->wqueue[0] = sd_bus_message_ref(m);
1821 bus->wqueue_size = 1;
1826 /* Just append it to the queue. */
1828 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1831 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1834 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1839 *cookie = BUS_MESSAGE_COOKIE(m);
1844 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1845 return bus_send_internal(bus, m, cookie, false);
1848 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1851 assert_return(m, -EINVAL);
1856 assert_return(!bus_pid_changed(bus), -ECHILD);
1858 if (!BUS_IS_OPEN(bus->state))
1861 if (!streq_ptr(m->destination, destination)) {
1866 r = sd_bus_message_set_destination(m, destination);
1871 return sd_bus_send(bus, m, cookie);
1874 static usec_t calc_elapse(uint64_t usec) {
1875 if (usec == (uint64_t) -1)
1878 return now(CLOCK_MONOTONIC) + usec;
1881 static int timeout_compare(const void *a, const void *b) {
1882 const struct reply_callback *x = a, *y = b;
1884 if (x->timeout != 0 && y->timeout == 0)
1887 if (x->timeout == 0 && y->timeout != 0)
1890 if (x->timeout < y->timeout)
1893 if (x->timeout > y->timeout)
1899 _public_ int sd_bus_call_async(
1903 sd_bus_message_handler_t callback,
1907 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1908 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1911 assert_return(m, -EINVAL);
1912 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1913 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1914 assert_return(callback, -EINVAL);
1919 assert_return(!bus_pid_changed(bus), -ECHILD);
1920 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1922 if (!BUS_IS_OPEN(bus->state))
1925 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1929 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1933 r = bus_seal_message(bus, m, usec);
1937 r = bus_remarshal_message(bus, &m);
1941 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1945 s->reply_callback.callback = callback;
1947 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1948 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1950 s->reply_callback.cookie = 0;
1954 s->reply_callback.timeout = calc_elapse(m->timeout);
1955 if (s->reply_callback.timeout != 0) {
1956 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1958 s->reply_callback.timeout = 0;
1963 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1974 int bus_ensure_running(sd_bus *bus) {
1979 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1981 if (bus->state == BUS_RUNNING)
1985 r = sd_bus_process(bus, NULL);
1988 if (bus->state == BUS_RUNNING)
1993 r = sd_bus_wait(bus, (uint64_t) -1);
1999 _public_ int sd_bus_call(
2003 sd_bus_error *error,
2004 sd_bus_message **reply) {
2006 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2012 bus_assert_return(m, -EINVAL, error);
2013 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2014 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2015 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2020 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2021 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2023 if (!BUS_IS_OPEN(bus->state)) {
2028 r = bus_ensure_running(bus);
2032 i = bus->rqueue_size;
2034 r = bus_seal_message(bus, m, usec);
2038 r = bus_remarshal_message(bus, &m);
2042 r = bus_send_internal(bus, m, &cookie, true);
2046 timeout = calc_elapse(m->timeout);
2051 while (i < bus->rqueue_size) {
2052 sd_bus_message *incoming = NULL;
2054 incoming = bus->rqueue[i];
2056 if (incoming->reply_cookie == cookie) {
2057 /* Found a match! */
2059 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2061 log_debug_bus_message(incoming);
2063 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2065 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2069 sd_bus_message_unref(incoming);
2074 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2075 sd_bus_message_unref(incoming);
2078 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2079 r = sd_bus_error_copy(error, &incoming->error);
2080 sd_bus_message_unref(incoming);
2087 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2090 streq(bus->unique_name, incoming->sender)) {
2092 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2095 /* Our own message? Somebody is trying
2096 * to send its own client a message,
2097 * let's not dead-lock, let's fail
2100 sd_bus_message_unref(incoming);
2105 /* Try to read more, right-away */
2109 r = bus_read_message(bus, false, 0);
2111 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2112 bus_enter_closing(bus);
2124 n = now(CLOCK_MONOTONIC);
2132 left = (uint64_t) -1;
2134 r = bus_poll(bus, true, left);
2142 r = dispatch_wqueue(bus);
2144 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2145 bus_enter_closing(bus);
2154 return sd_bus_error_set_errno(error, r);
2157 _public_ int sd_bus_get_fd(sd_bus *bus) {
2159 assert_return(bus, -EINVAL);
2160 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2161 assert_return(!bus_pid_changed(bus), -ECHILD);
2163 return bus->input_fd;
2166 _public_ int sd_bus_get_events(sd_bus *bus) {
2169 assert_return(bus, -EINVAL);
2170 assert_return(!bus_pid_changed(bus), -ECHILD);
2172 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2175 if (bus->state == BUS_OPENING)
2177 else if (bus->state == BUS_AUTHENTICATING) {
2179 if (bus_socket_auth_needs_write(bus))
2184 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2185 if (bus->rqueue_size <= 0)
2187 if (bus->wqueue_size > 0)
2194 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2195 struct reply_callback *c;
2197 assert_return(bus, -EINVAL);
2198 assert_return(timeout_usec, -EINVAL);
2199 assert_return(!bus_pid_changed(bus), -ECHILD);
2201 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2204 if (bus->track_queue) {
2209 if (bus->state == BUS_CLOSING) {
2214 if (bus->state == BUS_AUTHENTICATING) {
2215 *timeout_usec = bus->auth_timeout;
2219 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2220 *timeout_usec = (uint64_t) -1;
2224 if (bus->rqueue_size > 0) {
2229 c = prioq_peek(bus->reply_callbacks_prioq);
2231 *timeout_usec = (uint64_t) -1;
2235 if (c->timeout == 0) {
2236 *timeout_usec = (uint64_t) -1;
2240 *timeout_usec = c->timeout;
2244 static int process_timeout(sd_bus *bus) {
2245 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2246 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2247 struct reply_callback *c;
2254 c = prioq_peek(bus->reply_callbacks_prioq);
2258 n = now(CLOCK_MONOTONIC);
2262 r = bus_message_new_synthetic_error(
2265 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2270 r = bus_seal_synthetic_message(bus, m);
2274 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2277 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2280 slot = container_of(c, sd_bus_slot, reply_callback);
2282 bus->iteration_counter ++;
2284 bus->current_message = m;
2285 bus->current_slot = sd_bus_slot_ref(slot);
2286 bus->current_handler = c->callback;
2287 bus->current_userdata = slot->userdata;
2288 r = c->callback(m, slot->userdata, &error_buffer);
2289 bus->current_userdata = NULL;
2290 bus->current_handler = NULL;
2291 bus->current_slot = NULL;
2292 bus->current_message = NULL;
2294 if (slot->floating) {
2295 bus_slot_disconnect(slot);
2296 sd_bus_slot_unref(slot);
2299 sd_bus_slot_unref(slot);
2301 return bus_maybe_reply_error(m, r, &error_buffer);
2304 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2308 if (bus->state != BUS_HELLO)
2311 /* Let's make sure the first message on the bus is the HELLO
2312 * reply. But note that we don't actually parse the message
2313 * here (we leave that to the usual handling), we just verify
2314 * we don't let any earlier msg through. */
2316 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2317 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2320 if (m->reply_cookie != 1)
2326 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2327 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2328 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2329 struct reply_callback *c;
2336 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2337 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2340 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2343 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2346 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2352 slot = container_of(c, sd_bus_slot, reply_callback);
2354 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2356 /* If the reply contained a file descriptor which we
2357 * didn't want we pass an error instead. */
2359 r = bus_message_new_synthetic_error(
2362 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2367 /* Copy over original timestamp */
2368 synthetic_reply->realtime = m->realtime;
2369 synthetic_reply->monotonic = m->monotonic;
2370 synthetic_reply->seqnum = m->seqnum;
2372 r = bus_seal_synthetic_message(bus, synthetic_reply);
2376 m = synthetic_reply;
2378 r = sd_bus_message_rewind(m, true);
2383 if (c->timeout != 0) {
2384 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2388 bus->current_slot = sd_bus_slot_ref(slot);
2389 bus->current_handler = c->callback;
2390 bus->current_userdata = slot->userdata;
2391 r = c->callback(m, slot->userdata, &error_buffer);
2392 bus->current_userdata = NULL;
2393 bus->current_handler = NULL;
2394 bus->current_slot = NULL;
2396 if (slot->floating) {
2397 bus_slot_disconnect(slot);
2398 sd_bus_slot_unref(slot);
2401 sd_bus_slot_unref(slot);
2403 return bus_maybe_reply_error(m, r, &error_buffer);
2406 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2407 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2408 struct filter_callback *l;
2415 bus->filter_callbacks_modified = false;
2417 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2420 if (bus->filter_callbacks_modified)
2423 /* Don't run this more than once per iteration */
2424 if (l->last_iteration == bus->iteration_counter)
2427 l->last_iteration = bus->iteration_counter;
2429 r = sd_bus_message_rewind(m, true);
2433 slot = container_of(l, sd_bus_slot, filter_callback);
2435 bus->current_slot = sd_bus_slot_ref(slot);
2436 bus->current_handler = l->callback;
2437 bus->current_userdata = slot->userdata;
2438 r = l->callback(m, slot->userdata, &error_buffer);
2439 bus->current_userdata = NULL;
2440 bus->current_handler = NULL;
2441 bus->current_slot = sd_bus_slot_unref(slot);
2443 r = bus_maybe_reply_error(m, r, &error_buffer);
2449 } while (bus->filter_callbacks_modified);
2454 static int process_match(sd_bus *bus, sd_bus_message *m) {
2461 bus->match_callbacks_modified = false;
2463 r = bus_match_run(bus, &bus->match_callbacks, m);
2467 } while (bus->match_callbacks_modified);
2472 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2473 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2479 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2482 if (bus->manual_peer_interface)
2485 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2488 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2491 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2494 if (streq_ptr(m->member, "Ping"))
2495 r = sd_bus_message_new_method_return(m, &reply);
2496 else if (streq_ptr(m->member, "GetMachineId")) {
2500 r = sd_id128_get_machine(&id);
2504 r = sd_bus_message_new_method_return(m, &reply);
2508 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2510 r = sd_bus_message_new_method_errorf(
2512 SD_BUS_ERROR_UNKNOWN_METHOD,
2513 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2519 r = sd_bus_send(bus, reply, NULL);
2526 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2530 /* If we got a message with a file descriptor which we didn't
2531 * want to accept, then let's drop it. How can this even
2532 * happen? For example, when the kernel queues a message into
2533 * an activatable names's queue which allows fds, and then is
2534 * delivered to us later even though we ourselves did not
2537 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2543 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2546 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2547 return 1; /* just eat it up */
2549 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2552 static int process_message(sd_bus *bus, sd_bus_message *m) {
2558 bus->current_message = m;
2559 bus->iteration_counter++;
2561 log_debug_bus_message(m);
2563 r = process_hello(bus, m);
2567 r = process_reply(bus, m);
2571 r = process_fd_check(bus, m);
2575 r = process_filter(bus, m);
2579 r = process_match(bus, m);
2583 r = process_builtin(bus, m);
2587 r = bus_process_object(bus, m);
2590 bus->current_message = NULL;
2594 static int dispatch_track(sd_bus *bus) {
2597 if (!bus->track_queue)
2600 bus_track_dispatch(bus->track_queue);
2604 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2605 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2609 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2611 r = process_timeout(bus);
2615 r = dispatch_wqueue(bus);
2619 r = dispatch_track(bus);
2623 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2629 r = process_message(bus, m);
2634 r = sd_bus_message_rewind(m, true);
2643 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2645 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2646 strna(sd_bus_message_get_sender(m)),
2647 strna(sd_bus_message_get_path(m)),
2648 strna(sd_bus_message_get_interface(m)),
2649 strna(sd_bus_message_get_member(m)));
2651 r = sd_bus_reply_method_errorf(
2653 SD_BUS_ERROR_UNKNOWN_OBJECT,
2654 "Unknown object '%s'.", m->path);
2668 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2669 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2670 struct reply_callback *c;
2674 assert(bus->state == BUS_CLOSING);
2676 c = ordered_hashmap_first(bus->reply_callbacks);
2678 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2681 /* First, fail all outstanding method calls */
2682 r = bus_message_new_synthetic_error(
2685 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2690 r = bus_seal_synthetic_message(bus, m);
2694 if (c->timeout != 0) {
2695 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2699 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2702 slot = container_of(c, sd_bus_slot, reply_callback);
2704 bus->iteration_counter++;
2706 bus->current_message = m;
2707 bus->current_slot = sd_bus_slot_ref(slot);
2708 bus->current_handler = c->callback;
2709 bus->current_userdata = slot->userdata;
2710 r = c->callback(m, slot->userdata, &error_buffer);
2711 bus->current_userdata = NULL;
2712 bus->current_handler = NULL;
2713 bus->current_slot = NULL;
2714 bus->current_message = NULL;
2716 if (slot->floating) {
2717 bus_slot_disconnect(slot);
2718 sd_bus_slot_unref(slot);
2721 sd_bus_slot_unref(slot);
2723 return bus_maybe_reply_error(m, r, &error_buffer);
2726 /* Then, synthesize a Disconnected message */
2727 r = sd_bus_message_new_signal(
2730 "/org/freedesktop/DBus/Local",
2731 "org.freedesktop.DBus.Local",
2736 bus_message_set_sender_local(bus, m);
2738 r = bus_seal_synthetic_message(bus, m);
2744 bus->current_message = m;
2745 bus->iteration_counter++;
2747 r = process_filter(bus, m);
2751 r = process_match(bus, m);
2763 bus->current_message = NULL;
2768 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2769 BUS_DONT_DESTROY(bus);
2772 /* Returns 0 when we didn't do anything. This should cause the
2773 * caller to invoke sd_bus_wait() before returning the next
2774 * time. Returns > 0 when we did something, which possibly
2775 * means *ret is filled in with an unprocessed message. */
2777 assert_return(bus, -EINVAL);
2778 assert_return(!bus_pid_changed(bus), -ECHILD);
2780 /* We don't allow recursively invoking sd_bus_process(). */
2781 assert_return(!bus->current_message, -EBUSY);
2782 assert(!bus->current_slot);
2784 switch (bus->state) {
2793 r = bus_socket_process_opening(bus);
2794 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2795 bus_enter_closing(bus);
2803 case BUS_AUTHENTICATING:
2804 r = bus_socket_process_authenticating(bus);
2805 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2806 bus_enter_closing(bus);
2818 r = process_running(bus, hint_priority, priority, ret);
2819 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2820 bus_enter_closing(bus);
2830 return process_closing(bus, ret);
2833 assert_not_reached("Unknown state");
2836 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2837 return bus_process_internal(bus, false, 0, ret);
2840 /// UNNEEDED by elogind
2842 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2843 return bus_process_internal(bus, true, priority, ret);
2847 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2848 struct pollfd p[2] = {};
2851 usec_t m = USEC_INFINITY;
2855 if (bus->state == BUS_CLOSING)
2858 if (!BUS_IS_OPEN(bus->state))
2861 e = sd_bus_get_events(bus);
2866 /* The caller really needs some more data, he doesn't
2867 * care about what's already read, or any timeouts
2868 * except its own. */
2872 /* The caller wants to process if there's something to
2873 * process, but doesn't care otherwise */
2875 r = sd_bus_get_timeout(bus, &until);
2880 nw = now(CLOCK_MONOTONIC);
2881 m = until > nw ? until - nw : 0;
2885 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2888 p[0].fd = bus->input_fd;
2889 if (bus->output_fd == bus->input_fd) {
2893 p[0].events = e & POLLIN;
2894 p[1].fd = bus->output_fd;
2895 p[1].events = e & POLLOUT;
2899 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2903 return r > 0 ? 1 : 0;
2906 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2908 assert_return(bus, -EINVAL);
2909 assert_return(!bus_pid_changed(bus), -ECHILD);
2911 if (bus->state == BUS_CLOSING)
2914 if (!BUS_IS_OPEN(bus->state))
2917 if (bus->rqueue_size > 0)
2920 return bus_poll(bus, false, timeout_usec);
2923 _public_ int sd_bus_flush(sd_bus *bus) {
2926 assert_return(bus, -EINVAL);
2927 assert_return(!bus_pid_changed(bus), -ECHILD);
2929 if (bus->state == BUS_CLOSING)
2932 if (!BUS_IS_OPEN(bus->state))
2935 r = bus_ensure_running(bus);
2939 if (bus->wqueue_size <= 0)
2943 r = dispatch_wqueue(bus);
2945 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2946 bus_enter_closing(bus);
2953 if (bus->wqueue_size <= 0)
2956 r = bus_poll(bus, false, (uint64_t) -1);
2962 _public_ int sd_bus_add_filter(
2965 sd_bus_message_handler_t callback,
2970 assert_return(bus, -EINVAL);
2971 assert_return(callback, -EINVAL);
2972 assert_return(!bus_pid_changed(bus), -ECHILD);
2974 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2978 s->filter_callback.callback = callback;
2980 bus->filter_callbacks_modified = true;
2981 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2989 _public_ int sd_bus_add_match(
2993 sd_bus_message_handler_t callback,
2996 struct bus_match_component *components = NULL;
2997 unsigned n_components = 0;
2998 sd_bus_slot *s = NULL;
3001 assert_return(bus, -EINVAL);
3002 assert_return(match, -EINVAL);
3003 assert_return(!bus_pid_changed(bus), -ECHILD);
3005 r = bus_match_parse(match, &components, &n_components);
3009 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3015 s->match_callback.callback = callback;
3016 s->match_callback.cookie = ++bus->match_cookie;
3018 if (bus->bus_client) {
3019 enum bus_match_scope scope;
3021 scope = bus_match_get_scope(components, n_components);
3023 /* Do not install server-side matches for matches
3024 * against the local service, interface or bus
3026 if (scope != BUS_MATCH_LOCAL) {
3028 if (!bus->is_kernel) {
3029 /* When this is not a kernel transport, we
3030 * store the original match string, so that we
3031 * can use it to remove the match again */
3033 s->match_callback.match_string = strdup(match);
3034 if (!s->match_callback.match_string) {
3040 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3044 s->match_added = true;
3048 bus->match_callbacks_modified = true;
3049 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3058 bus_match_parse_free(components, n_components);
3059 sd_bus_slot_unref(s);
3064 /// UNNEEDED by elogind
3066 int bus_remove_match_by_string(
3069 sd_bus_message_handler_t callback,
3072 struct bus_match_component *components = NULL;
3073 unsigned n_components = 0;
3074 struct match_callback *c;
3077 assert_return(bus, -EINVAL);
3078 assert_return(match, -EINVAL);
3079 assert_return(!bus_pid_changed(bus), -ECHILD);
3081 r = bus_match_parse(match, &components, &n_components);
3085 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3089 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3092 bus_match_parse_free(components, n_components);
3098 bool bus_pid_changed(sd_bus *bus) {
3101 /* We don't support people creating a bus connection and
3102 * keeping it around over a fork(). Let's complain. */
3104 return bus->original_pid != getpid();
3107 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3108 sd_bus *bus = userdata;
3113 r = sd_bus_process(bus, NULL);
3120 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3121 sd_bus *bus = userdata;
3126 r = sd_bus_process(bus, NULL);
3133 static int prepare_callback(sd_event_source *s, void *userdata) {
3134 sd_bus *bus = userdata;
3141 e = sd_bus_get_events(bus);
3145 if (bus->output_fd != bus->input_fd) {
3147 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3151 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3155 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3160 r = sd_bus_get_timeout(bus, &until);
3166 j = sd_event_source_set_time(bus->time_event_source, until);
3171 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3178 static int quit_callback(sd_event_source *event, void *userdata) {
3179 sd_bus *bus = userdata;
3189 static int attach_io_events(sd_bus *bus) {
3194 if (bus->input_fd < 0)
3200 if (!bus->input_io_event_source) {
3201 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3205 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3209 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3213 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3215 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3220 if (bus->output_fd != bus->input_fd) {
3221 assert(bus->output_fd >= 0);
3223 if (!bus->output_io_event_source) {
3224 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3228 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3232 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3234 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3243 static void detach_io_events(sd_bus *bus) {
3246 if (bus->input_io_event_source) {
3247 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3248 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3251 if (bus->output_io_event_source) {
3252 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3253 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3257 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3260 assert_return(bus, -EINVAL);
3261 assert_return(!bus->event, -EBUSY);
3263 assert(!bus->input_io_event_source);
3264 assert(!bus->output_io_event_source);
3265 assert(!bus->time_event_source);
3268 bus->event = sd_event_ref(event);
3270 r = sd_event_default(&bus->event);
3275 bus->event_priority = priority;
3277 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3281 r = sd_event_source_set_priority(bus->time_event_source, priority);
3285 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3289 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3293 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3297 r = attach_io_events(bus);
3304 sd_bus_detach_event(bus);
3308 _public_ int sd_bus_detach_event(sd_bus *bus) {
3309 assert_return(bus, -EINVAL);
3314 detach_io_events(bus);
3316 if (bus->time_event_source) {
3317 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3318 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3321 if (bus->quit_event_source) {
3322 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3323 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3326 bus->event = sd_event_unref(bus->event);
3330 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3331 assert_return(bus, NULL);
3336 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3337 assert_return(bus, NULL);
3339 return bus->current_message;
3342 /// UNNEEDED by elogind
3344 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3345 assert_return(bus, NULL);
3347 return bus->current_slot;
3351 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3352 assert_return(bus, NULL);
3354 return bus->current_handler;
3357 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3358 assert_return(bus, NULL);
3360 return bus->current_userdata;
3363 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3368 assert(default_bus);
3371 return !!*default_bus;
3374 *ret = sd_bus_ref(*default_bus);
3382 b->default_bus_ptr = default_bus;
3390 _public_ int sd_bus_default_system(sd_bus **ret) {
3391 static thread_local sd_bus *default_system_bus = NULL;
3393 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3396 _public_ int sd_bus_default_user(sd_bus **ret) {
3397 /// elogind does not support user buses
3399 static thread_local sd_bus *default_user_bus = NULL;
3401 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3403 return sd_bus_default_system(ret);
3407 _public_ int sd_bus_default(sd_bus **ret) {
3411 /* Let's try our best to reuse another cached connection. If
3412 * the starter bus type is set, connect via our normal
3413 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3414 * we can share the connection with the user/system default
3417 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3419 if (streq(e, "system"))
3420 return sd_bus_default_system(ret);
3421 /// elogind does not support systemd units
3423 else if (STR_IN_SET(e, "user", "session"))
3424 return sd_bus_default_user(ret);
3428 /* No type is specified, so we have not other option than to
3429 * use the starter address if it is set. */
3431 e = secure_getenv("DBUS_STARTER_ADDRESS");
3433 static thread_local sd_bus *default_starter_bus = NULL;
3435 return bus_default(sd_bus_open, &default_starter_bus, ret);
3438 /* Finally, if nothing is set use the cached connection for
3439 * the right scope */
3440 /// elogind does not support systemd units
3442 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3443 return sd_bus_default_user(ret);
3446 return sd_bus_default_system(ret);
3449 /// UNNEEDED by elogind
3451 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3452 assert_return(b, -EINVAL);
3453 assert_return(tid, -EINVAL);
3454 assert_return(!bus_pid_changed(b), -ECHILD);
3462 return sd_event_get_tid(b->event, tid);
3467 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3468 _cleanup_free_ char *e = NULL;
3471 assert_return(object_path_is_valid(prefix), -EINVAL);
3472 assert_return(external_id, -EINVAL);
3473 assert_return(ret_path, -EINVAL);
3475 e = bus_label_escape(external_id);
3479 ret = strjoin(prefix, "/", e, NULL);
3487 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3491 assert_return(object_path_is_valid(path), -EINVAL);
3492 assert_return(object_path_is_valid(prefix), -EINVAL);
3493 assert_return(external_id, -EINVAL);
3495 e = object_path_startswith(path, prefix);
3497 *external_id = NULL;
3501 ret = bus_label_unescape(e);
3510 _public_ int sd_bus_try_close(sd_bus *bus) {
3513 assert_return(bus, -EINVAL);
3514 assert_return(!bus_pid_changed(bus), -ECHILD);
3516 if (!bus->is_kernel)
3519 if (!BUS_IS_OPEN(bus->state))
3522 if (bus->rqueue_size > 0)
3525 if (bus->wqueue_size > 0)
3528 r = bus_kernel_try_close(bus);
3536 /// UNNEEDED by elogind
3538 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3539 assert_return(bus, -EINVAL);
3540 assert_return(description, -EINVAL);
3541 assert_return(bus->description, -ENXIO);
3542 assert_return(!bus_pid_changed(bus), -ECHILD);
3544 *description = bus->description;
3549 int bus_get_root_path(sd_bus *bus) {
3552 if (bus->cgroup_root)
3555 r = cg_get_root_path(&bus->cgroup_root);
3557 bus->cgroup_root = strdup("/");
3558 if (!bus->cgroup_root)
3567 /// UNNEEDED by elogind
3569 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3572 assert_return(bus, -EINVAL);
3573 assert_return(scope, -EINVAL);
3574 assert_return(!bus_pid_changed(bus), -ECHILD);
3576 if (bus->is_kernel) {
3577 _cleanup_free_ char *n = NULL;
3580 r = bus_kernel_get_bus_name(bus, &n);
3584 if (streq(n, "0-system")) {
3589 dash = strchr(n, '-');
3590 if (streq_ptr(dash, "-user")) {
3601 if (bus->is_system) {
3609 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3611 assert_return(bus, -EINVAL);
3612 assert_return(address, -EINVAL);
3613 assert_return(!bus_pid_changed(bus), -ECHILD);
3616 *address = bus->address;
3623 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3624 assert_return(bus, -EINVAL);
3625 assert_return(mask, -EINVAL);
3626 assert_return(!bus_pid_changed(bus), -ECHILD);
3628 *mask = bus->creds_mask;
3632 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3633 assert_return(bus, -EINVAL);
3634 assert_return(!bus_pid_changed(bus), -ECHILD);
3636 return bus->bus_client;
3639 _public_ int sd_bus_is_server(sd_bus *bus) {
3640 assert_return(bus, -EINVAL);
3641 assert_return(!bus_pid_changed(bus), -ECHILD);
3643 return bus->is_server;
3646 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3647 assert_return(bus, -EINVAL);
3648 assert_return(!bus_pid_changed(bus), -ECHILD);
3650 return bus->anonymous_auth;
3653 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3654 assert_return(bus, -EINVAL);
3655 assert_return(!bus_pid_changed(bus), -ECHILD);
3657 return bus->trusted;
3660 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3661 assert_return(bus, -EINVAL);
3662 assert_return(!bus_pid_changed(bus), -ECHILD);
3664 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);