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 else if (STR_IN_SET(e, "session", "user"))
1166 return sd_bus_open_user(ret);
1169 e = secure_getenv("DBUS_STARTER_ADDRESS");
1171 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1172 return sd_bus_open_user(ret);
1174 return sd_bus_open_system(ret);
1181 r = sd_bus_set_address(b, e);
1185 b->bus_client = true;
1187 /* We don't know whether the bus is trusted or not, so better
1188 * be safe, and authenticate everything */
1190 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1191 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1193 r = sd_bus_start(b);
1205 int bus_set_address_system(sd_bus *b) {
1209 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1211 return sd_bus_set_address(b, e);
1213 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1216 _public_ int sd_bus_open_system(sd_bus **ret) {
1220 assert_return(ret, -EINVAL);
1226 r = bus_set_address_system(b);
1230 b->bus_client = true;
1231 b->is_system = true;
1233 /* Let's do per-method access control on the system bus. We
1234 * need the caller's UID and capability set for that. */
1236 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1237 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1239 r = sd_bus_start(b);
1251 int bus_set_address_user(sd_bus *b) {
1258 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1260 return sd_bus_set_address(b, e);
1262 r = cg_pid_get_owner_uid(0, &uid);
1266 e = secure_getenv("XDG_RUNTIME_DIR");
1268 _cleanup_free_ char *ee = NULL;
1270 ee = bus_address_escape(e);
1274 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1276 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1284 _public_ int sd_bus_open_user(sd_bus **ret) {
1288 assert_return(ret, -EINVAL);
1294 r = bus_set_address_user(b);
1298 b->bus_client = true;
1301 /* We don't do any per-method access control on the user
1305 r = sd_bus_start(b);
1317 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1318 _cleanup_free_ char *e = NULL;
1319 char *m = NULL, *c = NULL;
1324 /* Let's see if we shall enter some container */
1325 m = strchr(host, ':');
1329 /* Let's make sure this is not a port of some kind,
1330 * and is a valid machine name. */
1331 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1334 /* Cut out the host part */
1335 t = strndupa(host, m - host - 1);
1336 e = bus_address_escape(t);
1340 c = strjoina(",argv4=--machine=", m);
1345 e = bus_address_escape(host);
1350 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1357 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1361 assert_return(host, -EINVAL);
1362 assert_return(ret, -EINVAL);
1364 r = sd_bus_new(&bus);
1368 r = bus_set_address_system_remote(bus, host);
1372 bus->bus_client = true;
1373 bus->trusted = false;
1374 bus->is_system = true;
1376 r = sd_bus_start(bus);
1388 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1389 _cleanup_free_ char *e = NULL;
1394 e = bus_address_escape(machine);
1398 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1405 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1409 assert_return(machine, -EINVAL);
1410 assert_return(ret, -EINVAL);
1411 assert_return(machine_name_is_valid(machine), -EINVAL);
1413 r = sd_bus_new(&bus);
1417 r = bus_set_address_system_machine(bus, machine);
1421 bus->bus_client = true;
1422 bus->trusted = false;
1423 bus->is_system = true;
1425 r = sd_bus_start(bus);
1437 _public_ void sd_bus_close(sd_bus *bus) {
1441 if (bus->state == BUS_CLOSED)
1443 if (bus_pid_changed(bus))
1446 bus->state = BUS_CLOSED;
1448 sd_bus_detach_event(bus);
1450 /* Drop all queued messages so that they drop references to
1451 * the bus object and the bus may be freed */
1452 bus_reset_queues(bus);
1454 if (!bus->is_kernel)
1457 /* We'll leave the fd open in case this is a kernel bus, since
1458 * there might still be memblocks around that reference this
1459 * bus, and they might need to invoke the KDBUS_CMD_FREE
1460 * ioctl on the fd when they are freed. */
1463 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1471 return sd_bus_unref(bus);
1474 static void bus_enter_closing(sd_bus *bus) {
1477 if (bus->state != BUS_OPENING &&
1478 bus->state != BUS_AUTHENTICATING &&
1479 bus->state != BUS_HELLO &&
1480 bus->state != BUS_RUNNING)
1483 bus->state = BUS_CLOSING;
1486 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1487 assert_return(bus, NULL);
1489 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1494 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1500 i = REFCNT_DEC(bus->n_ref);
1508 /// UNNEEDED by elogind
1510 _public_ int sd_bus_is_open(sd_bus *bus) {
1512 assert_return(bus, -EINVAL);
1513 assert_return(!bus_pid_changed(bus), -ECHILD);
1515 return BUS_IS_OPEN(bus->state);
1519 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1522 assert_return(bus, -EINVAL);
1523 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1524 assert_return(!bus_pid_changed(bus), -ECHILD);
1526 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1529 if (type == SD_BUS_TYPE_UNIX_FD) {
1530 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1533 r = bus_ensure_running(bus);
1537 return bus->can_fds;
1540 return bus_type_is_valid(type);
1543 /// UNNEEDED by elogind
1545 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1548 assert_return(bus, -EINVAL);
1549 assert_return(id, -EINVAL);
1550 assert_return(!bus_pid_changed(bus), -ECHILD);
1552 r = bus_ensure_running(bus);
1556 *id = bus->server_id;
1561 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1566 /* If we copy the same message to multiple
1567 * destinations, avoid using the same cookie
1569 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1574 timeout = BUS_DEFAULT_TIMEOUT;
1576 return bus_message_seal(m, ++b->cookie, timeout);
1579 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1580 bool remarshal = false;
1584 /* wrong packet version */
1585 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1588 /* wrong packet endianness */
1589 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1592 /* TODO: kdbus-messages received from the kernel contain data which is
1593 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1594 * force remarshaling of the message. Technically, we could just
1595 * recreate the kdbus message, but that is non-trivial as other parts of
1596 * the message refer to m->kdbus already. This should be fixed! */
1597 if ((*m)->kdbus && (*m)->release_kdbus)
1600 return remarshal ? bus_message_remarshal(b, m) : 0;
1603 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1607 /* Fake some timestamps, if they were requested, and not
1608 * already initialized */
1609 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1610 if (m->realtime <= 0)
1611 m->realtime = now(CLOCK_REALTIME);
1613 if (m->monotonic <= 0)
1614 m->monotonic = now(CLOCK_MONOTONIC);
1617 /* The bus specification says the serial number cannot be 0,
1618 * hence let's fill something in for synthetic messages. Since
1619 * synthetic messages might have a fake sender and we don't
1620 * want to interfere with the real sender's serial numbers we
1621 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1622 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1623 * even though kdbus can do 64bit. */
1624 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1627 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1634 r = bus_kernel_write_message(bus, m, hint_sync_call);
1636 r = bus_socket_write_message(bus, m, idx);
1641 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1642 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1643 bus_message_type_to_string(m->header->type),
1644 strna(sd_bus_message_get_sender(m)),
1645 strna(sd_bus_message_get_destination(m)),
1646 strna(sd_bus_message_get_path(m)),
1647 strna(sd_bus_message_get_interface(m)),
1648 strna(sd_bus_message_get_member(m)),
1649 BUS_MESSAGE_COOKIE(m),
1651 strna(m->error.message));
1656 static int dispatch_wqueue(sd_bus *bus) {
1660 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1662 while (bus->wqueue_size > 0) {
1664 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1668 /* Didn't do anything this time */
1670 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1671 /* Fully written. Let's drop the entry from
1674 * This isn't particularly optimized, but
1675 * well, this is supposed to be our worst-case
1676 * buffer only, and the socket buffer is
1677 * supposed to be our primary buffer, and if
1678 * it got full, then all bets are off
1681 bus->wqueue_size --;
1682 sd_bus_message_unref(bus->wqueue[0]);
1683 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1693 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1697 return bus_kernel_read_message(bus, hint_priority, priority);
1699 return bus_socket_read_message(bus);
1702 int bus_rqueue_make_room(sd_bus *bus) {
1705 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1708 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1714 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1719 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1721 /* Note that the priority logic is only available on kdbus,
1722 * where the rqueue is unused. We check the rqueue here
1723 * anyway, because it's simple... */
1726 if (bus->rqueue_size > 0) {
1727 /* Dispatch a queued message */
1729 *m = bus->rqueue[0];
1730 bus->rqueue_size --;
1731 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1735 /* Try to read a new message */
1736 r = bus_read_message(bus, hint_priority, priority);
1746 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1747 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1750 assert_return(m, -EINVAL);
1755 assert_return(!bus_pid_changed(bus), -ECHILD);
1756 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1758 if (!BUS_IS_OPEN(bus->state))
1762 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1769 /* If the cookie number isn't kept, then we know that no reply
1771 if (!cookie && !m->sealed)
1772 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1774 r = bus_seal_message(bus, m, 0);
1778 /* Remarshall if we have to. This will possibly unref the
1779 * message and place a replacement in m */
1780 r = bus_remarshal_message(bus, &m);
1784 /* If this is a reply and no reply was requested, then let's
1785 * suppress this, if we can */
1789 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1792 r = bus_write_message(bus, m, hint_sync_call, &idx);
1794 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1795 bus_enter_closing(bus);
1802 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1803 /* Wasn't fully written. So let's remember how
1804 * much was written. Note that the first entry
1805 * of the wqueue array is always allocated so
1806 * that we always can remember how much was
1808 bus->wqueue[0] = sd_bus_message_ref(m);
1809 bus->wqueue_size = 1;
1814 /* Just append it to the queue. */
1816 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1819 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1822 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1827 *cookie = BUS_MESSAGE_COOKIE(m);
1832 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1833 return bus_send_internal(bus, m, cookie, false);
1836 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1839 assert_return(m, -EINVAL);
1844 assert_return(!bus_pid_changed(bus), -ECHILD);
1846 if (!BUS_IS_OPEN(bus->state))
1849 if (!streq_ptr(m->destination, destination)) {
1854 r = sd_bus_message_set_destination(m, destination);
1859 return sd_bus_send(bus, m, cookie);
1862 static usec_t calc_elapse(uint64_t usec) {
1863 if (usec == (uint64_t) -1)
1866 return now(CLOCK_MONOTONIC) + usec;
1869 static int timeout_compare(const void *a, const void *b) {
1870 const struct reply_callback *x = a, *y = b;
1872 if (x->timeout != 0 && y->timeout == 0)
1875 if (x->timeout == 0 && y->timeout != 0)
1878 if (x->timeout < y->timeout)
1881 if (x->timeout > y->timeout)
1887 _public_ int sd_bus_call_async(
1891 sd_bus_message_handler_t callback,
1895 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1896 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1899 assert_return(m, -EINVAL);
1900 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1901 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1902 assert_return(callback, -EINVAL);
1907 assert_return(!bus_pid_changed(bus), -ECHILD);
1908 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1910 if (!BUS_IS_OPEN(bus->state))
1913 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1917 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1921 r = bus_seal_message(bus, m, usec);
1925 r = bus_remarshal_message(bus, &m);
1929 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1933 s->reply_callback.callback = callback;
1935 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1936 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1938 s->reply_callback.cookie = 0;
1942 s->reply_callback.timeout = calc_elapse(m->timeout);
1943 if (s->reply_callback.timeout != 0) {
1944 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1946 s->reply_callback.timeout = 0;
1951 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1962 int bus_ensure_running(sd_bus *bus) {
1967 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1969 if (bus->state == BUS_RUNNING)
1973 r = sd_bus_process(bus, NULL);
1976 if (bus->state == BUS_RUNNING)
1981 r = sd_bus_wait(bus, (uint64_t) -1);
1987 _public_ int sd_bus_call(
1991 sd_bus_error *error,
1992 sd_bus_message **reply) {
1994 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2000 bus_assert_return(m, -EINVAL, error);
2001 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2002 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2003 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2008 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2009 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2011 if (!BUS_IS_OPEN(bus->state)) {
2016 r = bus_ensure_running(bus);
2020 i = bus->rqueue_size;
2022 r = bus_seal_message(bus, m, usec);
2026 r = bus_remarshal_message(bus, &m);
2030 r = bus_send_internal(bus, m, &cookie, true);
2034 timeout = calc_elapse(m->timeout);
2039 while (i < bus->rqueue_size) {
2040 sd_bus_message *incoming = NULL;
2042 incoming = bus->rqueue[i];
2044 if (incoming->reply_cookie == cookie) {
2045 /* Found a match! */
2047 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2049 log_debug_bus_message(incoming);
2051 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2053 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2057 sd_bus_message_unref(incoming);
2062 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2063 sd_bus_message_unref(incoming);
2066 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2067 r = sd_bus_error_copy(error, &incoming->error);
2068 sd_bus_message_unref(incoming);
2075 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2078 streq(bus->unique_name, incoming->sender)) {
2080 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2083 /* Our own message? Somebody is trying
2084 * to send its own client a message,
2085 * let's not dead-lock, let's fail
2088 sd_bus_message_unref(incoming);
2093 /* Try to read more, right-away */
2097 r = bus_read_message(bus, false, 0);
2099 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2100 bus_enter_closing(bus);
2112 n = now(CLOCK_MONOTONIC);
2120 left = (uint64_t) -1;
2122 r = bus_poll(bus, true, left);
2130 r = dispatch_wqueue(bus);
2132 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2133 bus_enter_closing(bus);
2142 return sd_bus_error_set_errno(error, r);
2145 _public_ int sd_bus_get_fd(sd_bus *bus) {
2147 assert_return(bus, -EINVAL);
2148 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2149 assert_return(!bus_pid_changed(bus), -ECHILD);
2151 return bus->input_fd;
2154 _public_ int sd_bus_get_events(sd_bus *bus) {
2157 assert_return(bus, -EINVAL);
2158 assert_return(!bus_pid_changed(bus), -ECHILD);
2160 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2163 if (bus->state == BUS_OPENING)
2165 else if (bus->state == BUS_AUTHENTICATING) {
2167 if (bus_socket_auth_needs_write(bus))
2172 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2173 if (bus->rqueue_size <= 0)
2175 if (bus->wqueue_size > 0)
2182 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2183 struct reply_callback *c;
2185 assert_return(bus, -EINVAL);
2186 assert_return(timeout_usec, -EINVAL);
2187 assert_return(!bus_pid_changed(bus), -ECHILD);
2189 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2192 if (bus->track_queue) {
2197 if (bus->state == BUS_CLOSING) {
2202 if (bus->state == BUS_AUTHENTICATING) {
2203 *timeout_usec = bus->auth_timeout;
2207 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2208 *timeout_usec = (uint64_t) -1;
2212 if (bus->rqueue_size > 0) {
2217 c = prioq_peek(bus->reply_callbacks_prioq);
2219 *timeout_usec = (uint64_t) -1;
2223 if (c->timeout == 0) {
2224 *timeout_usec = (uint64_t) -1;
2228 *timeout_usec = c->timeout;
2232 static int process_timeout(sd_bus *bus) {
2233 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2234 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2235 struct reply_callback *c;
2242 c = prioq_peek(bus->reply_callbacks_prioq);
2246 n = now(CLOCK_MONOTONIC);
2250 r = bus_message_new_synthetic_error(
2253 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2258 r = bus_seal_synthetic_message(bus, m);
2262 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2265 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2268 slot = container_of(c, sd_bus_slot, reply_callback);
2270 bus->iteration_counter ++;
2272 bus->current_message = m;
2273 bus->current_slot = sd_bus_slot_ref(slot);
2274 bus->current_handler = c->callback;
2275 bus->current_userdata = slot->userdata;
2276 r = c->callback(m, slot->userdata, &error_buffer);
2277 bus->current_userdata = NULL;
2278 bus->current_handler = NULL;
2279 bus->current_slot = NULL;
2280 bus->current_message = NULL;
2282 if (slot->floating) {
2283 bus_slot_disconnect(slot);
2284 sd_bus_slot_unref(slot);
2287 sd_bus_slot_unref(slot);
2289 return bus_maybe_reply_error(m, r, &error_buffer);
2292 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2296 if (bus->state != BUS_HELLO)
2299 /* Let's make sure the first message on the bus is the HELLO
2300 * reply. But note that we don't actually parse the message
2301 * here (we leave that to the usual handling), we just verify
2302 * we don't let any earlier msg through. */
2304 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2305 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2308 if (m->reply_cookie != 1)
2314 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2315 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2316 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2317 struct reply_callback *c;
2324 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2325 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2328 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2331 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2334 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2340 slot = container_of(c, sd_bus_slot, reply_callback);
2342 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2344 /* If the reply contained a file descriptor which we
2345 * didn't want we pass an error instead. */
2347 r = bus_message_new_synthetic_error(
2350 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2355 /* Copy over original timestamp */
2356 synthetic_reply->realtime = m->realtime;
2357 synthetic_reply->monotonic = m->monotonic;
2358 synthetic_reply->seqnum = m->seqnum;
2360 r = bus_seal_synthetic_message(bus, synthetic_reply);
2364 m = synthetic_reply;
2366 r = sd_bus_message_rewind(m, true);
2371 if (c->timeout != 0) {
2372 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2376 bus->current_slot = sd_bus_slot_ref(slot);
2377 bus->current_handler = c->callback;
2378 bus->current_userdata = slot->userdata;
2379 r = c->callback(m, slot->userdata, &error_buffer);
2380 bus->current_userdata = NULL;
2381 bus->current_handler = NULL;
2382 bus->current_slot = NULL;
2384 if (slot->floating) {
2385 bus_slot_disconnect(slot);
2386 sd_bus_slot_unref(slot);
2389 sd_bus_slot_unref(slot);
2391 return bus_maybe_reply_error(m, r, &error_buffer);
2394 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2395 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2396 struct filter_callback *l;
2403 bus->filter_callbacks_modified = false;
2405 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2408 if (bus->filter_callbacks_modified)
2411 /* Don't run this more than once per iteration */
2412 if (l->last_iteration == bus->iteration_counter)
2415 l->last_iteration = bus->iteration_counter;
2417 r = sd_bus_message_rewind(m, true);
2421 slot = container_of(l, sd_bus_slot, filter_callback);
2423 bus->current_slot = sd_bus_slot_ref(slot);
2424 bus->current_handler = l->callback;
2425 bus->current_userdata = slot->userdata;
2426 r = l->callback(m, slot->userdata, &error_buffer);
2427 bus->current_userdata = NULL;
2428 bus->current_handler = NULL;
2429 bus->current_slot = sd_bus_slot_unref(slot);
2431 r = bus_maybe_reply_error(m, r, &error_buffer);
2437 } while (bus->filter_callbacks_modified);
2442 static int process_match(sd_bus *bus, sd_bus_message *m) {
2449 bus->match_callbacks_modified = false;
2451 r = bus_match_run(bus, &bus->match_callbacks, m);
2455 } while (bus->match_callbacks_modified);
2460 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2461 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2467 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2470 if (bus->manual_peer_interface)
2473 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2476 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2479 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2482 if (streq_ptr(m->member, "Ping"))
2483 r = sd_bus_message_new_method_return(m, &reply);
2484 else if (streq_ptr(m->member, "GetMachineId")) {
2488 r = sd_id128_get_machine(&id);
2492 r = sd_bus_message_new_method_return(m, &reply);
2496 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2498 r = sd_bus_message_new_method_errorf(
2500 SD_BUS_ERROR_UNKNOWN_METHOD,
2501 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2507 r = sd_bus_send(bus, reply, NULL);
2514 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2518 /* If we got a message with a file descriptor which we didn't
2519 * want to accept, then let's drop it. How can this even
2520 * happen? For example, when the kernel queues a message into
2521 * an activatable names's queue which allows fds, and then is
2522 * delivered to us later even though we ourselves did not
2525 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2531 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2534 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2535 return 1; /* just eat it up */
2537 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2540 static int process_message(sd_bus *bus, sd_bus_message *m) {
2546 bus->current_message = m;
2547 bus->iteration_counter++;
2549 log_debug_bus_message(m);
2551 r = process_hello(bus, m);
2555 r = process_reply(bus, m);
2559 r = process_fd_check(bus, m);
2563 r = process_filter(bus, m);
2567 r = process_match(bus, m);
2571 r = process_builtin(bus, m);
2575 r = bus_process_object(bus, m);
2578 bus->current_message = NULL;
2582 static int dispatch_track(sd_bus *bus) {
2585 if (!bus->track_queue)
2588 bus_track_dispatch(bus->track_queue);
2592 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2593 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2597 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2599 r = process_timeout(bus);
2603 r = dispatch_wqueue(bus);
2607 r = dispatch_track(bus);
2611 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2617 r = process_message(bus, m);
2622 r = sd_bus_message_rewind(m, true);
2631 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2633 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2634 strna(sd_bus_message_get_sender(m)),
2635 strna(sd_bus_message_get_path(m)),
2636 strna(sd_bus_message_get_interface(m)),
2637 strna(sd_bus_message_get_member(m)));
2639 r = sd_bus_reply_method_errorf(
2641 SD_BUS_ERROR_UNKNOWN_OBJECT,
2642 "Unknown object '%s'.", m->path);
2656 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2657 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2658 struct reply_callback *c;
2662 assert(bus->state == BUS_CLOSING);
2664 c = ordered_hashmap_first(bus->reply_callbacks);
2666 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2669 /* First, fail all outstanding method calls */
2670 r = bus_message_new_synthetic_error(
2673 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2678 r = bus_seal_synthetic_message(bus, m);
2682 if (c->timeout != 0) {
2683 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2687 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2690 slot = container_of(c, sd_bus_slot, reply_callback);
2692 bus->iteration_counter++;
2694 bus->current_message = m;
2695 bus->current_slot = sd_bus_slot_ref(slot);
2696 bus->current_handler = c->callback;
2697 bus->current_userdata = slot->userdata;
2698 r = c->callback(m, slot->userdata, &error_buffer);
2699 bus->current_userdata = NULL;
2700 bus->current_handler = NULL;
2701 bus->current_slot = NULL;
2702 bus->current_message = NULL;
2704 if (slot->floating) {
2705 bus_slot_disconnect(slot);
2706 sd_bus_slot_unref(slot);
2709 sd_bus_slot_unref(slot);
2711 return bus_maybe_reply_error(m, r, &error_buffer);
2714 /* Then, synthesize a Disconnected message */
2715 r = sd_bus_message_new_signal(
2718 "/org/freedesktop/DBus/Local",
2719 "org.freedesktop.DBus.Local",
2724 bus_message_set_sender_local(bus, m);
2726 r = bus_seal_synthetic_message(bus, m);
2732 bus->current_message = m;
2733 bus->iteration_counter++;
2735 r = process_filter(bus, m);
2739 r = process_match(bus, m);
2751 bus->current_message = NULL;
2756 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2757 BUS_DONT_DESTROY(bus);
2760 /* Returns 0 when we didn't do anything. This should cause the
2761 * caller to invoke sd_bus_wait() before returning the next
2762 * time. Returns > 0 when we did something, which possibly
2763 * means *ret is filled in with an unprocessed message. */
2765 assert_return(bus, -EINVAL);
2766 assert_return(!bus_pid_changed(bus), -ECHILD);
2768 /* We don't allow recursively invoking sd_bus_process(). */
2769 assert_return(!bus->current_message, -EBUSY);
2770 assert(!bus->current_slot);
2772 switch (bus->state) {
2781 r = bus_socket_process_opening(bus);
2782 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2783 bus_enter_closing(bus);
2791 case BUS_AUTHENTICATING:
2792 r = bus_socket_process_authenticating(bus);
2793 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2794 bus_enter_closing(bus);
2806 r = process_running(bus, hint_priority, priority, ret);
2807 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2808 bus_enter_closing(bus);
2818 return process_closing(bus, ret);
2821 assert_not_reached("Unknown state");
2824 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2825 return bus_process_internal(bus, false, 0, ret);
2828 /// UNNEEDED by elogind
2830 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2831 return bus_process_internal(bus, true, priority, ret);
2835 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2836 struct pollfd p[2] = {};
2839 usec_t m = USEC_INFINITY;
2843 if (bus->state == BUS_CLOSING)
2846 if (!BUS_IS_OPEN(bus->state))
2849 e = sd_bus_get_events(bus);
2854 /* The caller really needs some more data, he doesn't
2855 * care about what's already read, or any timeouts
2856 * except its own. */
2860 /* The caller wants to process if there's something to
2861 * process, but doesn't care otherwise */
2863 r = sd_bus_get_timeout(bus, &until);
2868 nw = now(CLOCK_MONOTONIC);
2869 m = until > nw ? until - nw : 0;
2873 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2876 p[0].fd = bus->input_fd;
2877 if (bus->output_fd == bus->input_fd) {
2881 p[0].events = e & POLLIN;
2882 p[1].fd = bus->output_fd;
2883 p[1].events = e & POLLOUT;
2887 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2891 return r > 0 ? 1 : 0;
2894 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2896 assert_return(bus, -EINVAL);
2897 assert_return(!bus_pid_changed(bus), -ECHILD);
2899 if (bus->state == BUS_CLOSING)
2902 if (!BUS_IS_OPEN(bus->state))
2905 if (bus->rqueue_size > 0)
2908 return bus_poll(bus, false, timeout_usec);
2911 _public_ int sd_bus_flush(sd_bus *bus) {
2914 assert_return(bus, -EINVAL);
2915 assert_return(!bus_pid_changed(bus), -ECHILD);
2917 if (bus->state == BUS_CLOSING)
2920 if (!BUS_IS_OPEN(bus->state))
2923 r = bus_ensure_running(bus);
2927 if (bus->wqueue_size <= 0)
2931 r = dispatch_wqueue(bus);
2933 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2934 bus_enter_closing(bus);
2941 if (bus->wqueue_size <= 0)
2944 r = bus_poll(bus, false, (uint64_t) -1);
2950 _public_ int sd_bus_add_filter(
2953 sd_bus_message_handler_t callback,
2958 assert_return(bus, -EINVAL);
2959 assert_return(callback, -EINVAL);
2960 assert_return(!bus_pid_changed(bus), -ECHILD);
2962 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2966 s->filter_callback.callback = callback;
2968 bus->filter_callbacks_modified = true;
2969 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2977 _public_ int sd_bus_add_match(
2981 sd_bus_message_handler_t callback,
2984 struct bus_match_component *components = NULL;
2985 unsigned n_components = 0;
2986 sd_bus_slot *s = NULL;
2989 assert_return(bus, -EINVAL);
2990 assert_return(match, -EINVAL);
2991 assert_return(!bus_pid_changed(bus), -ECHILD);
2993 r = bus_match_parse(match, &components, &n_components);
2997 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3003 s->match_callback.callback = callback;
3004 s->match_callback.cookie = ++bus->match_cookie;
3006 if (bus->bus_client) {
3007 enum bus_match_scope scope;
3009 scope = bus_match_get_scope(components, n_components);
3011 /* Do not install server-side matches for matches
3012 * against the local service, interface or bus
3014 if (scope != BUS_MATCH_LOCAL) {
3016 if (!bus->is_kernel) {
3017 /* When this is not a kernel transport, we
3018 * store the original match string, so that we
3019 * can use it to remove the match again */
3021 s->match_callback.match_string = strdup(match);
3022 if (!s->match_callback.match_string) {
3028 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3032 s->match_added = true;
3036 bus->match_callbacks_modified = true;
3037 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3046 bus_match_parse_free(components, n_components);
3047 sd_bus_slot_unref(s);
3052 /// UNNEEDED by elogind
3054 int bus_remove_match_by_string(
3057 sd_bus_message_handler_t callback,
3060 struct bus_match_component *components = NULL;
3061 unsigned n_components = 0;
3062 struct match_callback *c;
3065 assert_return(bus, -EINVAL);
3066 assert_return(match, -EINVAL);
3067 assert_return(!bus_pid_changed(bus), -ECHILD);
3069 r = bus_match_parse(match, &components, &n_components);
3073 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3077 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3080 bus_match_parse_free(components, n_components);
3086 bool bus_pid_changed(sd_bus *bus) {
3089 /* We don't support people creating a bus connection and
3090 * keeping it around over a fork(). Let's complain. */
3092 return bus->original_pid != getpid();
3095 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3096 sd_bus *bus = userdata;
3101 r = sd_bus_process(bus, NULL);
3108 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3109 sd_bus *bus = userdata;
3114 r = sd_bus_process(bus, NULL);
3121 static int prepare_callback(sd_event_source *s, void *userdata) {
3122 sd_bus *bus = userdata;
3129 e = sd_bus_get_events(bus);
3133 if (bus->output_fd != bus->input_fd) {
3135 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3139 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3143 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3148 r = sd_bus_get_timeout(bus, &until);
3154 j = sd_event_source_set_time(bus->time_event_source, until);
3159 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3166 static int quit_callback(sd_event_source *event, void *userdata) {
3167 sd_bus *bus = userdata;
3177 static int attach_io_events(sd_bus *bus) {
3182 if (bus->input_fd < 0)
3188 if (!bus->input_io_event_source) {
3189 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3193 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3197 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3201 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3203 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3208 if (bus->output_fd != bus->input_fd) {
3209 assert(bus->output_fd >= 0);
3211 if (!bus->output_io_event_source) {
3212 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3216 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3220 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3222 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3231 static void detach_io_events(sd_bus *bus) {
3234 if (bus->input_io_event_source) {
3235 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3236 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3239 if (bus->output_io_event_source) {
3240 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3241 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3245 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3248 assert_return(bus, -EINVAL);
3249 assert_return(!bus->event, -EBUSY);
3251 assert(!bus->input_io_event_source);
3252 assert(!bus->output_io_event_source);
3253 assert(!bus->time_event_source);
3256 bus->event = sd_event_ref(event);
3258 r = sd_event_default(&bus->event);
3263 bus->event_priority = priority;
3265 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3269 r = sd_event_source_set_priority(bus->time_event_source, priority);
3273 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3277 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3281 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3285 r = attach_io_events(bus);
3292 sd_bus_detach_event(bus);
3296 _public_ int sd_bus_detach_event(sd_bus *bus) {
3297 assert_return(bus, -EINVAL);
3302 detach_io_events(bus);
3304 if (bus->time_event_source) {
3305 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3306 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3309 if (bus->quit_event_source) {
3310 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3311 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3314 bus->event = sd_event_unref(bus->event);
3318 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3319 assert_return(bus, NULL);
3324 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3325 assert_return(bus, NULL);
3327 return bus->current_message;
3330 /// UNNEEDED by elogind
3332 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3333 assert_return(bus, NULL);
3335 return bus->current_slot;
3339 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3340 assert_return(bus, NULL);
3342 return bus->current_handler;
3345 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3346 assert_return(bus, NULL);
3348 return bus->current_userdata;
3351 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3356 assert(default_bus);
3359 return !!*default_bus;
3362 *ret = sd_bus_ref(*default_bus);
3370 b->default_bus_ptr = default_bus;
3378 _public_ int sd_bus_default_system(sd_bus **ret) {
3379 static thread_local sd_bus *default_system_bus = NULL;
3381 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3384 _public_ int sd_bus_default_user(sd_bus **ret) {
3385 static thread_local sd_bus *default_user_bus = NULL;
3387 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3390 _public_ int sd_bus_default(sd_bus **ret) {
3394 /* Let's try our best to reuse another cached connection. If
3395 * the starter bus type is set, connect via our normal
3396 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3397 * we can share the connection with the user/system default
3400 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3402 if (streq(e, "system"))
3403 return sd_bus_default_system(ret);
3404 else if (STR_IN_SET(e, "user", "session"))
3405 return sd_bus_default_user(ret);
3408 /* No type is specified, so we have not other option than to
3409 * use the starter address if it is set. */
3411 e = secure_getenv("DBUS_STARTER_ADDRESS");
3413 static thread_local sd_bus *default_starter_bus = NULL;
3415 return bus_default(sd_bus_open, &default_starter_bus, ret);
3418 /* Finally, if nothing is set use the cached connection for
3419 * the right scope */
3421 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3422 return sd_bus_default_user(ret);
3424 return sd_bus_default_system(ret);
3427 /// UNNEEDED by elogind
3429 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3430 assert_return(b, -EINVAL);
3431 assert_return(tid, -EINVAL);
3432 assert_return(!bus_pid_changed(b), -ECHILD);
3440 return sd_event_get_tid(b->event, tid);
3445 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3446 _cleanup_free_ char *e = NULL;
3449 assert_return(object_path_is_valid(prefix), -EINVAL);
3450 assert_return(external_id, -EINVAL);
3451 assert_return(ret_path, -EINVAL);
3453 e = bus_label_escape(external_id);
3457 ret = strjoin(prefix, "/", e, NULL);
3465 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3469 assert_return(object_path_is_valid(path), -EINVAL);
3470 assert_return(object_path_is_valid(prefix), -EINVAL);
3471 assert_return(external_id, -EINVAL);
3473 e = object_path_startswith(path, prefix);
3475 *external_id = NULL;
3479 ret = bus_label_unescape(e);
3488 _public_ int sd_bus_try_close(sd_bus *bus) {
3491 assert_return(bus, -EINVAL);
3492 assert_return(!bus_pid_changed(bus), -ECHILD);
3494 if (!bus->is_kernel)
3497 if (!BUS_IS_OPEN(bus->state))
3500 if (bus->rqueue_size > 0)
3503 if (bus->wqueue_size > 0)
3506 r = bus_kernel_try_close(bus);
3514 /// UNNEEDED by elogind
3516 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3517 assert_return(bus, -EINVAL);
3518 assert_return(description, -EINVAL);
3519 assert_return(bus->description, -ENXIO);
3520 assert_return(!bus_pid_changed(bus), -ECHILD);
3522 *description = bus->description;
3527 int bus_get_root_path(sd_bus *bus) {
3530 if (bus->cgroup_root)
3533 r = cg_get_root_path(&bus->cgroup_root);
3535 bus->cgroup_root = strdup("/");
3536 if (!bus->cgroup_root)
3545 /// UNNEEDED by elogind
3547 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3550 assert_return(bus, -EINVAL);
3551 assert_return(scope, -EINVAL);
3552 assert_return(!bus_pid_changed(bus), -ECHILD);
3554 if (bus->is_kernel) {
3555 _cleanup_free_ char *n = NULL;
3558 r = bus_kernel_get_bus_name(bus, &n);
3562 if (streq(n, "0-system")) {
3567 dash = strchr(n, '-');
3568 if (streq_ptr(dash, "-user")) {
3579 if (bus->is_system) {
3587 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3589 assert_return(bus, -EINVAL);
3590 assert_return(address, -EINVAL);
3591 assert_return(!bus_pid_changed(bus), -ECHILD);
3594 *address = bus->address;
3601 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3602 assert_return(bus, -EINVAL);
3603 assert_return(mask, -EINVAL);
3604 assert_return(!bus_pid_changed(bus), -ECHILD);
3606 *mask = bus->creds_mask;
3610 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3611 assert_return(bus, -EINVAL);
3612 assert_return(!bus_pid_changed(bus), -ECHILD);
3614 return bus->bus_client;
3617 _public_ int sd_bus_is_server(sd_bus *bus) {
3618 assert_return(bus, -EINVAL);
3619 assert_return(!bus_pid_changed(bus), -ECHILD);
3621 return bus->is_server;
3624 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3625 assert_return(bus, -EINVAL);
3626 assert_return(!bus_pid_changed(bus), -ECHILD);
3628 return bus->anonymous_auth;
3631 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3632 assert_return(bus, -EINVAL);
3633 assert_return(!bus_pid_changed(bus), -ECHILD);
3635 return bus->trusted;
3638 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3639 assert_return(bus, -EINVAL);
3640 assert_return(!bus_pid_changed(bus), -ECHILD);
3642 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);