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;
1042 } else if (!container_kdbus_available && (b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1043 r = bus_container_connect_socket(b);
1045 else if (b->kernel) {
1046 r = bus_kernel_connect(b);
1047 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1048 kdbus_available = true;
1049 } else if (!kdbus_available && b->sockaddr.sa.sa_family != AF_UNSPEC)
1050 r = bus_socket_connect(b);
1056 r = attach_io_events(b);
1061 b->last_connect_error = -r;
1064 r = bus_parse_next_address(b);
1068 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1072 int bus_next_address(sd_bus *b) {
1075 bus_reset_parsed_address(b);
1076 return bus_start_address(b);
1079 static int bus_start_fd(sd_bus *b) {
1084 assert(b->input_fd >= 0);
1085 assert(b->output_fd >= 0);
1087 r = fd_nonblock(b->input_fd, true);
1091 r = fd_cloexec(b->input_fd, true);
1095 if (b->input_fd != b->output_fd) {
1096 r = fd_nonblock(b->output_fd, true);
1100 r = fd_cloexec(b->output_fd, true);
1105 if (fstat(b->input_fd, &st) < 0)
1108 if (S_ISCHR(b->input_fd))
1109 return bus_kernel_take_fd(b);
1111 return bus_socket_take_fd(b);
1114 _public_ int sd_bus_start(sd_bus *bus) {
1117 assert_return(bus, -EINVAL);
1118 assert_return(bus->state == BUS_UNSET, -EPERM);
1119 assert_return(!bus_pid_changed(bus), -ECHILD);
1121 bus->state = BUS_OPENING;
1123 if (bus->is_server && bus->bus_client)
1126 if (bus->input_fd >= 0)
1127 r = bus_start_fd(bus);
1128 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1129 r = bus_start_address(bus);
1138 return bus_send_hello(bus);
1141 _public_ int sd_bus_open(sd_bus **ret) {
1146 assert_return(ret, -EINVAL);
1148 /* Let's connect to the starter bus if it is set, and
1149 * otherwise to the bus that is appropropriate for the scope
1150 * we are running in */
1152 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1154 if (streq(e, "system"))
1155 return sd_bus_open_system(ret);
1156 else if (STR_IN_SET(e, "session", "user"))
1157 return sd_bus_open_user(ret);
1160 e = secure_getenv("DBUS_STARTER_ADDRESS");
1162 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1163 return sd_bus_open_user(ret);
1165 return sd_bus_open_system(ret);
1172 r = sd_bus_set_address(b, e);
1176 b->bus_client = true;
1178 /* We don't know whether the bus is trusted or not, so better
1179 * be safe, and authenticate everything */
1181 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1182 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1184 r = sd_bus_start(b);
1196 int bus_set_address_system(sd_bus *b) {
1200 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1202 return sd_bus_set_address(b, e);
1204 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1207 _public_ int sd_bus_open_system(sd_bus **ret) {
1211 assert_return(ret, -EINVAL);
1217 r = bus_set_address_system(b);
1221 b->bus_client = true;
1222 b->is_system = true;
1224 /* Let's do per-method access control on the system bus. We
1225 * need the caller's UID and capability set for that. */
1227 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1228 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1230 r = sd_bus_start(b);
1242 int bus_set_address_user(sd_bus *b) {
1247 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1249 return sd_bus_set_address(b, e);
1251 e = secure_getenv("XDG_RUNTIME_DIR");
1253 _cleanup_free_ char *ee = NULL;
1255 ee = bus_address_escape(e);
1259 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1261 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1269 _public_ int sd_bus_open_user(sd_bus **ret) {
1273 assert_return(ret, -EINVAL);
1279 r = bus_set_address_user(b);
1283 b->bus_client = true;
1286 /* We don't do any per-method access control on the user
1290 r = sd_bus_start(b);
1302 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1303 _cleanup_free_ char *e = NULL;
1304 char *m = NULL, *c = NULL;
1309 /* Let's see if we shall enter some container */
1310 m = strchr(host, ':');
1314 /* Let's make sure this is not a port of some kind,
1315 * and is a valid machine name. */
1316 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1319 /* Cut out the host part */
1320 t = strndupa(host, m - host - 1);
1321 e = bus_address_escape(t);
1325 c = strjoina(",argv4=--machine=", m);
1330 e = bus_address_escape(host);
1335 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1342 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1346 assert_return(host, -EINVAL);
1347 assert_return(ret, -EINVAL);
1349 r = sd_bus_new(&bus);
1353 r = bus_set_address_system_remote(bus, host);
1357 bus->bus_client = true;
1358 bus->trusted = false;
1359 bus->is_system = true;
1361 r = sd_bus_start(bus);
1373 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1374 _cleanup_free_ char *e = NULL;
1379 e = bus_address_escape(machine);
1383 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1390 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1394 assert_return(machine, -EINVAL);
1395 assert_return(ret, -EINVAL);
1396 assert_return(machine_name_is_valid(machine), -EINVAL);
1398 r = sd_bus_new(&bus);
1402 r = bus_set_address_system_machine(bus, machine);
1406 bus->bus_client = true;
1407 bus->trusted = false;
1408 bus->is_system = true;
1410 r = sd_bus_start(bus);
1422 _public_ void sd_bus_close(sd_bus *bus) {
1426 if (bus->state == BUS_CLOSED)
1428 if (bus_pid_changed(bus))
1431 bus->state = BUS_CLOSED;
1433 sd_bus_detach_event(bus);
1435 /* Drop all queued messages so that they drop references to
1436 * the bus object and the bus may be freed */
1437 bus_reset_queues(bus);
1439 if (!bus->is_kernel)
1442 /* We'll leave the fd open in case this is a kernel bus, since
1443 * there might still be memblocks around that reference this
1444 * bus, and they might need to invoke the KDBUS_CMD_FREE
1445 * ioctl on the fd when they are freed. */
1448 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1456 return sd_bus_unref(bus);
1459 static void bus_enter_closing(sd_bus *bus) {
1462 if (bus->state != BUS_OPENING &&
1463 bus->state != BUS_AUTHENTICATING &&
1464 bus->state != BUS_HELLO &&
1465 bus->state != BUS_RUNNING)
1468 bus->state = BUS_CLOSING;
1471 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1472 assert_return(bus, NULL);
1474 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1479 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1485 i = REFCNT_DEC(bus->n_ref);
1493 /// UNNEEDED by elogind
1495 _public_ int sd_bus_is_open(sd_bus *bus) {
1497 assert_return(bus, -EINVAL);
1498 assert_return(!bus_pid_changed(bus), -ECHILD);
1500 return BUS_IS_OPEN(bus->state);
1504 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1507 assert_return(bus, -EINVAL);
1508 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1509 assert_return(!bus_pid_changed(bus), -ECHILD);
1511 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1514 if (type == SD_BUS_TYPE_UNIX_FD) {
1515 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1518 r = bus_ensure_running(bus);
1522 return bus->can_fds;
1525 return bus_type_is_valid(type);
1528 /// UNNEEDED by elogind
1530 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1533 assert_return(bus, -EINVAL);
1534 assert_return(id, -EINVAL);
1535 assert_return(!bus_pid_changed(bus), -ECHILD);
1537 r = bus_ensure_running(bus);
1541 *id = bus->server_id;
1546 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1551 /* If we copy the same message to multiple
1552 * destinations, avoid using the same cookie
1554 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1559 timeout = BUS_DEFAULT_TIMEOUT;
1561 return bus_message_seal(m, ++b->cookie, timeout);
1564 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1565 bool remarshal = false;
1569 /* wrong packet version */
1570 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1573 /* wrong packet endianness */
1574 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1577 /* TODO: kdbus-messages received from the kernel contain data which is
1578 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1579 * force remarshaling of the message. Technically, we could just
1580 * recreate the kdbus message, but that is non-trivial as other parts of
1581 * the message refer to m->kdbus already. This should be fixed! */
1582 if ((*m)->kdbus && (*m)->release_kdbus)
1585 return remarshal ? bus_message_remarshal(b, m) : 0;
1588 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1592 /* Fake some timestamps, if they were requested, and not
1593 * already initialized */
1594 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1595 if (m->realtime <= 0)
1596 m->realtime = now(CLOCK_REALTIME);
1598 if (m->monotonic <= 0)
1599 m->monotonic = now(CLOCK_MONOTONIC);
1602 /* The bus specification says the serial number cannot be 0,
1603 * hence let's fill something in for synthetic messages. Since
1604 * synthetic messages might have a fake sender and we don't
1605 * want to interfere with the real sender's serial numbers we
1606 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1607 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1608 * even though kdbus can do 64bit. */
1609 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1612 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1619 r = bus_kernel_write_message(bus, m, hint_sync_call);
1621 r = bus_socket_write_message(bus, m, idx);
1626 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1627 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1628 bus_message_type_to_string(m->header->type),
1629 strna(sd_bus_message_get_sender(m)),
1630 strna(sd_bus_message_get_destination(m)),
1631 strna(sd_bus_message_get_path(m)),
1632 strna(sd_bus_message_get_interface(m)),
1633 strna(sd_bus_message_get_member(m)),
1634 BUS_MESSAGE_COOKIE(m),
1636 strna(m->error.message));
1641 static int dispatch_wqueue(sd_bus *bus) {
1645 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1647 while (bus->wqueue_size > 0) {
1649 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1653 /* Didn't do anything this time */
1655 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1656 /* Fully written. Let's drop the entry from
1659 * This isn't particularly optimized, but
1660 * well, this is supposed to be our worst-case
1661 * buffer only, and the socket buffer is
1662 * supposed to be our primary buffer, and if
1663 * it got full, then all bets are off
1666 bus->wqueue_size --;
1667 sd_bus_message_unref(bus->wqueue[0]);
1668 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1678 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1682 return bus_kernel_read_message(bus, hint_priority, priority);
1684 return bus_socket_read_message(bus);
1687 int bus_rqueue_make_room(sd_bus *bus) {
1690 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1693 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1699 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1704 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1706 /* Note that the priority logic is only available on kdbus,
1707 * where the rqueue is unused. We check the rqueue here
1708 * anyway, because it's simple... */
1711 if (bus->rqueue_size > 0) {
1712 /* Dispatch a queued message */
1714 *m = bus->rqueue[0];
1715 bus->rqueue_size --;
1716 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1720 /* Try to read a new message */
1721 r = bus_read_message(bus, hint_priority, priority);
1731 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1732 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1735 assert_return(m, -EINVAL);
1740 assert_return(!bus_pid_changed(bus), -ECHILD);
1741 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1743 if (!BUS_IS_OPEN(bus->state))
1747 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1754 /* If the cookie number isn't kept, then we know that no reply
1756 if (!cookie && !m->sealed)
1757 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1759 r = bus_seal_message(bus, m, 0);
1763 /* Remarshall if we have to. This will possibly unref the
1764 * message and place a replacement in m */
1765 r = bus_remarshal_message(bus, &m);
1769 /* If this is a reply and no reply was requested, then let's
1770 * suppress this, if we can */
1774 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1777 r = bus_write_message(bus, m, hint_sync_call, &idx);
1779 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1780 bus_enter_closing(bus);
1787 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1788 /* Wasn't fully written. So let's remember how
1789 * much was written. Note that the first entry
1790 * of the wqueue array is always allocated so
1791 * that we always can remember how much was
1793 bus->wqueue[0] = sd_bus_message_ref(m);
1794 bus->wqueue_size = 1;
1799 /* Just append it to the queue. */
1801 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1804 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1807 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1812 *cookie = BUS_MESSAGE_COOKIE(m);
1817 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1818 return bus_send_internal(bus, m, cookie, false);
1821 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1824 assert_return(m, -EINVAL);
1829 assert_return(!bus_pid_changed(bus), -ECHILD);
1831 if (!BUS_IS_OPEN(bus->state))
1834 if (!streq_ptr(m->destination, destination)) {
1839 r = sd_bus_message_set_destination(m, destination);
1844 return sd_bus_send(bus, m, cookie);
1847 static usec_t calc_elapse(uint64_t usec) {
1848 if (usec == (uint64_t) -1)
1851 return now(CLOCK_MONOTONIC) + usec;
1854 static int timeout_compare(const void *a, const void *b) {
1855 const struct reply_callback *x = a, *y = b;
1857 if (x->timeout != 0 && y->timeout == 0)
1860 if (x->timeout == 0 && y->timeout != 0)
1863 if (x->timeout < y->timeout)
1866 if (x->timeout > y->timeout)
1872 _public_ int sd_bus_call_async(
1876 sd_bus_message_handler_t callback,
1880 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1881 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1884 assert_return(m, -EINVAL);
1885 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1886 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1887 assert_return(callback, -EINVAL);
1892 assert_return(!bus_pid_changed(bus), -ECHILD);
1893 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1895 if (!BUS_IS_OPEN(bus->state))
1898 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1902 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1906 r = bus_seal_message(bus, m, usec);
1910 r = bus_remarshal_message(bus, &m);
1914 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1918 s->reply_callback.callback = callback;
1920 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1921 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1923 s->reply_callback.cookie = 0;
1927 s->reply_callback.timeout = calc_elapse(m->timeout);
1928 if (s->reply_callback.timeout != 0) {
1929 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1931 s->reply_callback.timeout = 0;
1936 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1947 int bus_ensure_running(sd_bus *bus) {
1952 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1954 if (bus->state == BUS_RUNNING)
1958 r = sd_bus_process(bus, NULL);
1961 if (bus->state == BUS_RUNNING)
1966 r = sd_bus_wait(bus, (uint64_t) -1);
1972 _public_ int sd_bus_call(
1976 sd_bus_error *error,
1977 sd_bus_message **reply) {
1979 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1985 bus_assert_return(m, -EINVAL, error);
1986 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
1987 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
1988 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
1993 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
1994 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
1996 if (!BUS_IS_OPEN(bus->state)) {
2001 r = bus_ensure_running(bus);
2005 i = bus->rqueue_size;
2007 r = bus_seal_message(bus, m, usec);
2011 r = bus_remarshal_message(bus, &m);
2015 r = bus_send_internal(bus, m, &cookie, true);
2019 timeout = calc_elapse(m->timeout);
2024 while (i < bus->rqueue_size) {
2025 sd_bus_message *incoming = NULL;
2027 incoming = bus->rqueue[i];
2029 if (incoming->reply_cookie == cookie) {
2030 /* Found a match! */
2032 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2034 log_debug_bus_message(incoming);
2036 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2038 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2042 sd_bus_message_unref(incoming);
2047 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2048 sd_bus_message_unref(incoming);
2051 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2052 r = sd_bus_error_copy(error, &incoming->error);
2053 sd_bus_message_unref(incoming);
2060 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2063 streq(bus->unique_name, incoming->sender)) {
2065 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2068 /* Our own message? Somebody is trying
2069 * to send its own client a message,
2070 * let's not dead-lock, let's fail
2073 sd_bus_message_unref(incoming);
2078 /* Try to read more, right-away */
2082 r = bus_read_message(bus, false, 0);
2084 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2085 bus_enter_closing(bus);
2097 n = now(CLOCK_MONOTONIC);
2105 left = (uint64_t) -1;
2107 r = bus_poll(bus, true, left);
2115 r = dispatch_wqueue(bus);
2117 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2118 bus_enter_closing(bus);
2127 return sd_bus_error_set_errno(error, r);
2130 _public_ int sd_bus_get_fd(sd_bus *bus) {
2132 assert_return(bus, -EINVAL);
2133 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2134 assert_return(!bus_pid_changed(bus), -ECHILD);
2136 return bus->input_fd;
2139 _public_ int sd_bus_get_events(sd_bus *bus) {
2142 assert_return(bus, -EINVAL);
2143 assert_return(!bus_pid_changed(bus), -ECHILD);
2145 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2148 if (bus->state == BUS_OPENING)
2150 else if (bus->state == BUS_AUTHENTICATING) {
2152 if (bus_socket_auth_needs_write(bus))
2157 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2158 if (bus->rqueue_size <= 0)
2160 if (bus->wqueue_size > 0)
2167 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2168 struct reply_callback *c;
2170 assert_return(bus, -EINVAL);
2171 assert_return(timeout_usec, -EINVAL);
2172 assert_return(!bus_pid_changed(bus), -ECHILD);
2174 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2177 if (bus->track_queue) {
2182 if (bus->state == BUS_CLOSING) {
2187 if (bus->state == BUS_AUTHENTICATING) {
2188 *timeout_usec = bus->auth_timeout;
2192 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2193 *timeout_usec = (uint64_t) -1;
2197 if (bus->rqueue_size > 0) {
2202 c = prioq_peek(bus->reply_callbacks_prioq);
2204 *timeout_usec = (uint64_t) -1;
2208 if (c->timeout == 0) {
2209 *timeout_usec = (uint64_t) -1;
2213 *timeout_usec = c->timeout;
2217 static int process_timeout(sd_bus *bus) {
2218 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2219 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2220 struct reply_callback *c;
2227 c = prioq_peek(bus->reply_callbacks_prioq);
2231 n = now(CLOCK_MONOTONIC);
2235 r = bus_message_new_synthetic_error(
2238 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2243 r = bus_seal_synthetic_message(bus, m);
2247 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2250 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2253 slot = container_of(c, sd_bus_slot, reply_callback);
2255 bus->iteration_counter ++;
2257 bus->current_message = m;
2258 bus->current_slot = sd_bus_slot_ref(slot);
2259 bus->current_handler = c->callback;
2260 bus->current_userdata = slot->userdata;
2261 r = c->callback(m, slot->userdata, &error_buffer);
2262 bus->current_userdata = NULL;
2263 bus->current_handler = NULL;
2264 bus->current_slot = NULL;
2265 bus->current_message = NULL;
2267 if (slot->floating) {
2268 bus_slot_disconnect(slot);
2269 sd_bus_slot_unref(slot);
2272 sd_bus_slot_unref(slot);
2274 return bus_maybe_reply_error(m, r, &error_buffer);
2277 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2281 if (bus->state != BUS_HELLO)
2284 /* Let's make sure the first message on the bus is the HELLO
2285 * reply. But note that we don't actually parse the message
2286 * here (we leave that to the usual handling), we just verify
2287 * we don't let any earlier msg through. */
2289 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2290 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2293 if (m->reply_cookie != 1)
2299 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2300 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2301 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2302 struct reply_callback *c;
2309 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2310 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2313 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2316 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2319 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2325 slot = container_of(c, sd_bus_slot, reply_callback);
2327 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2329 /* If the reply contained a file descriptor which we
2330 * didn't want we pass an error instead. */
2332 r = bus_message_new_synthetic_error(
2335 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2340 /* Copy over original timestamp */
2341 synthetic_reply->realtime = m->realtime;
2342 synthetic_reply->monotonic = m->monotonic;
2343 synthetic_reply->seqnum = m->seqnum;
2345 r = bus_seal_synthetic_message(bus, synthetic_reply);
2349 m = synthetic_reply;
2351 r = sd_bus_message_rewind(m, true);
2356 if (c->timeout != 0) {
2357 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2361 bus->current_slot = sd_bus_slot_ref(slot);
2362 bus->current_handler = c->callback;
2363 bus->current_userdata = slot->userdata;
2364 r = c->callback(m, slot->userdata, &error_buffer);
2365 bus->current_userdata = NULL;
2366 bus->current_handler = NULL;
2367 bus->current_slot = NULL;
2369 if (slot->floating) {
2370 bus_slot_disconnect(slot);
2371 sd_bus_slot_unref(slot);
2374 sd_bus_slot_unref(slot);
2376 return bus_maybe_reply_error(m, r, &error_buffer);
2379 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2380 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2381 struct filter_callback *l;
2388 bus->filter_callbacks_modified = false;
2390 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2393 if (bus->filter_callbacks_modified)
2396 /* Don't run this more than once per iteration */
2397 if (l->last_iteration == bus->iteration_counter)
2400 l->last_iteration = bus->iteration_counter;
2402 r = sd_bus_message_rewind(m, true);
2406 slot = container_of(l, sd_bus_slot, filter_callback);
2408 bus->current_slot = sd_bus_slot_ref(slot);
2409 bus->current_handler = l->callback;
2410 bus->current_userdata = slot->userdata;
2411 r = l->callback(m, slot->userdata, &error_buffer);
2412 bus->current_userdata = NULL;
2413 bus->current_handler = NULL;
2414 bus->current_slot = sd_bus_slot_unref(slot);
2416 r = bus_maybe_reply_error(m, r, &error_buffer);
2422 } while (bus->filter_callbacks_modified);
2427 static int process_match(sd_bus *bus, sd_bus_message *m) {
2434 bus->match_callbacks_modified = false;
2436 r = bus_match_run(bus, &bus->match_callbacks, m);
2440 } while (bus->match_callbacks_modified);
2445 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2446 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2452 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2455 if (bus->manual_peer_interface)
2458 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2461 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2464 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2467 if (streq_ptr(m->member, "Ping"))
2468 r = sd_bus_message_new_method_return(m, &reply);
2469 else if (streq_ptr(m->member, "GetMachineId")) {
2473 r = sd_id128_get_machine(&id);
2477 r = sd_bus_message_new_method_return(m, &reply);
2481 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2483 r = sd_bus_message_new_method_errorf(
2485 SD_BUS_ERROR_UNKNOWN_METHOD,
2486 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2492 r = sd_bus_send(bus, reply, NULL);
2499 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2503 /* If we got a message with a file descriptor which we didn't
2504 * want to accept, then let's drop it. How can this even
2505 * happen? For example, when the kernel queues a message into
2506 * an activatable names's queue which allows fds, and then is
2507 * delivered to us later even though we ourselves did not
2510 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2516 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2519 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2520 return 1; /* just eat it up */
2522 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2525 static int process_message(sd_bus *bus, sd_bus_message *m) {
2531 bus->current_message = m;
2532 bus->iteration_counter++;
2534 log_debug_bus_message(m);
2536 r = process_hello(bus, m);
2540 r = process_reply(bus, m);
2544 r = process_fd_check(bus, m);
2548 r = process_filter(bus, m);
2552 r = process_match(bus, m);
2556 r = process_builtin(bus, m);
2560 r = bus_process_object(bus, m);
2563 bus->current_message = NULL;
2567 static int dispatch_track(sd_bus *bus) {
2570 if (!bus->track_queue)
2573 bus_track_dispatch(bus->track_queue);
2577 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2578 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2582 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2584 r = process_timeout(bus);
2588 r = dispatch_wqueue(bus);
2592 r = dispatch_track(bus);
2596 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2602 r = process_message(bus, m);
2607 r = sd_bus_message_rewind(m, true);
2616 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2618 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2619 strna(sd_bus_message_get_sender(m)),
2620 strna(sd_bus_message_get_path(m)),
2621 strna(sd_bus_message_get_interface(m)),
2622 strna(sd_bus_message_get_member(m)));
2624 r = sd_bus_reply_method_errorf(
2626 SD_BUS_ERROR_UNKNOWN_OBJECT,
2627 "Unknown object '%s'.", m->path);
2641 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2642 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2643 struct reply_callback *c;
2647 assert(bus->state == BUS_CLOSING);
2649 c = ordered_hashmap_first(bus->reply_callbacks);
2651 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2654 /* First, fail all outstanding method calls */
2655 r = bus_message_new_synthetic_error(
2658 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2663 r = bus_seal_synthetic_message(bus, m);
2667 if (c->timeout != 0) {
2668 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2672 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2675 slot = container_of(c, sd_bus_slot, reply_callback);
2677 bus->iteration_counter++;
2679 bus->current_message = m;
2680 bus->current_slot = sd_bus_slot_ref(slot);
2681 bus->current_handler = c->callback;
2682 bus->current_userdata = slot->userdata;
2683 r = c->callback(m, slot->userdata, &error_buffer);
2684 bus->current_userdata = NULL;
2685 bus->current_handler = NULL;
2686 bus->current_slot = NULL;
2687 bus->current_message = NULL;
2689 if (slot->floating) {
2690 bus_slot_disconnect(slot);
2691 sd_bus_slot_unref(slot);
2694 sd_bus_slot_unref(slot);
2696 return bus_maybe_reply_error(m, r, &error_buffer);
2699 /* Then, synthesize a Disconnected message */
2700 r = sd_bus_message_new_signal(
2703 "/org/freedesktop/DBus/Local",
2704 "org.freedesktop.DBus.Local",
2709 bus_message_set_sender_local(bus, m);
2711 r = bus_seal_synthetic_message(bus, m);
2717 bus->current_message = m;
2718 bus->iteration_counter++;
2720 r = process_filter(bus, m);
2724 r = process_match(bus, m);
2736 bus->current_message = NULL;
2741 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2742 BUS_DONT_DESTROY(bus);
2745 /* Returns 0 when we didn't do anything. This should cause the
2746 * caller to invoke sd_bus_wait() before returning the next
2747 * time. Returns > 0 when we did something, which possibly
2748 * means *ret is filled in with an unprocessed message. */
2750 assert_return(bus, -EINVAL);
2751 assert_return(!bus_pid_changed(bus), -ECHILD);
2753 /* We don't allow recursively invoking sd_bus_process(). */
2754 assert_return(!bus->current_message, -EBUSY);
2755 assert(!bus->current_slot);
2757 switch (bus->state) {
2766 r = bus_socket_process_opening(bus);
2767 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2768 bus_enter_closing(bus);
2776 case BUS_AUTHENTICATING:
2777 r = bus_socket_process_authenticating(bus);
2778 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2779 bus_enter_closing(bus);
2791 r = process_running(bus, hint_priority, priority, ret);
2792 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2793 bus_enter_closing(bus);
2803 return process_closing(bus, ret);
2806 assert_not_reached("Unknown state");
2809 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2810 return bus_process_internal(bus, false, 0, ret);
2813 /// UNNEEDED by elogind
2815 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2816 return bus_process_internal(bus, true, priority, ret);
2820 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2821 struct pollfd p[2] = {};
2824 usec_t m = USEC_INFINITY;
2828 if (bus->state == BUS_CLOSING)
2831 if (!BUS_IS_OPEN(bus->state))
2834 e = sd_bus_get_events(bus);
2839 /* The caller really needs some more data, he doesn't
2840 * care about what's already read, or any timeouts
2841 * except its own. */
2845 /* The caller wants to process if there's something to
2846 * process, but doesn't care otherwise */
2848 r = sd_bus_get_timeout(bus, &until);
2853 nw = now(CLOCK_MONOTONIC);
2854 m = until > nw ? until - nw : 0;
2858 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2861 p[0].fd = bus->input_fd;
2862 if (bus->output_fd == bus->input_fd) {
2866 p[0].events = e & POLLIN;
2867 p[1].fd = bus->output_fd;
2868 p[1].events = e & POLLOUT;
2872 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2876 return r > 0 ? 1 : 0;
2879 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2881 assert_return(bus, -EINVAL);
2882 assert_return(!bus_pid_changed(bus), -ECHILD);
2884 if (bus->state == BUS_CLOSING)
2887 if (!BUS_IS_OPEN(bus->state))
2890 if (bus->rqueue_size > 0)
2893 return bus_poll(bus, false, timeout_usec);
2896 _public_ int sd_bus_flush(sd_bus *bus) {
2899 assert_return(bus, -EINVAL);
2900 assert_return(!bus_pid_changed(bus), -ECHILD);
2902 if (bus->state == BUS_CLOSING)
2905 if (!BUS_IS_OPEN(bus->state))
2908 r = bus_ensure_running(bus);
2912 if (bus->wqueue_size <= 0)
2916 r = dispatch_wqueue(bus);
2918 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2919 bus_enter_closing(bus);
2926 if (bus->wqueue_size <= 0)
2929 r = bus_poll(bus, false, (uint64_t) -1);
2935 _public_ int sd_bus_add_filter(
2938 sd_bus_message_handler_t callback,
2943 assert_return(bus, -EINVAL);
2944 assert_return(callback, -EINVAL);
2945 assert_return(!bus_pid_changed(bus), -ECHILD);
2947 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2951 s->filter_callback.callback = callback;
2953 bus->filter_callbacks_modified = true;
2954 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2962 _public_ int sd_bus_add_match(
2966 sd_bus_message_handler_t callback,
2969 struct bus_match_component *components = NULL;
2970 unsigned n_components = 0;
2971 sd_bus_slot *s = NULL;
2974 assert_return(bus, -EINVAL);
2975 assert_return(match, -EINVAL);
2976 assert_return(!bus_pid_changed(bus), -ECHILD);
2978 r = bus_match_parse(match, &components, &n_components);
2982 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2988 s->match_callback.callback = callback;
2989 s->match_callback.cookie = ++bus->match_cookie;
2991 if (bus->bus_client) {
2992 enum bus_match_scope scope;
2994 scope = bus_match_get_scope(components, n_components);
2996 /* Do not install server-side matches for matches
2997 * against the local service, interface or bus
2999 if (scope != BUS_MATCH_LOCAL) {
3001 if (!bus->is_kernel) {
3002 /* When this is not a kernel transport, we
3003 * store the original match string, so that we
3004 * can use it to remove the match again */
3006 s->match_callback.match_string = strdup(match);
3007 if (!s->match_callback.match_string) {
3013 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3017 s->match_added = true;
3021 bus->match_callbacks_modified = true;
3022 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3031 bus_match_parse_free(components, n_components);
3032 sd_bus_slot_unref(s);
3037 /// UNNEEDED by elogind
3039 int bus_remove_match_by_string(
3042 sd_bus_message_handler_t callback,
3045 struct bus_match_component *components = NULL;
3046 unsigned n_components = 0;
3047 struct match_callback *c;
3050 assert_return(bus, -EINVAL);
3051 assert_return(match, -EINVAL);
3052 assert_return(!bus_pid_changed(bus), -ECHILD);
3054 r = bus_match_parse(match, &components, &n_components);
3058 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3062 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3065 bus_match_parse_free(components, n_components);
3071 bool bus_pid_changed(sd_bus *bus) {
3074 /* We don't support people creating a bus connection and
3075 * keeping it around over a fork(). Let's complain. */
3077 return bus->original_pid != getpid();
3080 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3081 sd_bus *bus = userdata;
3086 r = sd_bus_process(bus, NULL);
3093 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3094 sd_bus *bus = userdata;
3099 r = sd_bus_process(bus, NULL);
3106 static int prepare_callback(sd_event_source *s, void *userdata) {
3107 sd_bus *bus = userdata;
3114 e = sd_bus_get_events(bus);
3118 if (bus->output_fd != bus->input_fd) {
3120 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3124 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3128 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3133 r = sd_bus_get_timeout(bus, &until);
3139 j = sd_event_source_set_time(bus->time_event_source, until);
3144 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3151 static int quit_callback(sd_event_source *event, void *userdata) {
3152 sd_bus *bus = userdata;
3162 static int attach_io_events(sd_bus *bus) {
3167 if (bus->input_fd < 0)
3173 if (!bus->input_io_event_source) {
3174 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3178 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3182 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3186 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3188 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3193 if (bus->output_fd != bus->input_fd) {
3194 assert(bus->output_fd >= 0);
3196 if (!bus->output_io_event_source) {
3197 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3201 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3205 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3207 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3216 static void detach_io_events(sd_bus *bus) {
3219 if (bus->input_io_event_source) {
3220 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3221 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3224 if (bus->output_io_event_source) {
3225 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3226 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3230 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3233 assert_return(bus, -EINVAL);
3234 assert_return(!bus->event, -EBUSY);
3236 assert(!bus->input_io_event_source);
3237 assert(!bus->output_io_event_source);
3238 assert(!bus->time_event_source);
3241 bus->event = sd_event_ref(event);
3243 r = sd_event_default(&bus->event);
3248 bus->event_priority = priority;
3250 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3254 r = sd_event_source_set_priority(bus->time_event_source, priority);
3258 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3262 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3266 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3270 r = attach_io_events(bus);
3277 sd_bus_detach_event(bus);
3281 _public_ int sd_bus_detach_event(sd_bus *bus) {
3282 assert_return(bus, -EINVAL);
3287 detach_io_events(bus);
3289 if (bus->time_event_source) {
3290 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3291 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3294 if (bus->quit_event_source) {
3295 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3296 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3299 bus->event = sd_event_unref(bus->event);
3303 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3304 assert_return(bus, NULL);
3309 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3310 assert_return(bus, NULL);
3312 return bus->current_message;
3315 /// UNNEEDED by elogind
3317 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3318 assert_return(bus, NULL);
3320 return bus->current_slot;
3324 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3325 assert_return(bus, NULL);
3327 return bus->current_handler;
3330 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3331 assert_return(bus, NULL);
3333 return bus->current_userdata;
3336 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3341 assert(default_bus);
3344 return !!*default_bus;
3347 *ret = sd_bus_ref(*default_bus);
3355 b->default_bus_ptr = default_bus;
3363 _public_ int sd_bus_default_system(sd_bus **ret) {
3364 static thread_local sd_bus *default_system_bus = NULL;
3366 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3369 _public_ int sd_bus_default_user(sd_bus **ret) {
3370 static thread_local sd_bus *default_user_bus = NULL;
3372 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3375 _public_ int sd_bus_default(sd_bus **ret) {
3379 /* Let's try our best to reuse another cached connection. If
3380 * the starter bus type is set, connect via our normal
3381 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3382 * we can share the connection with the user/system default
3385 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3387 if (streq(e, "system"))
3388 return sd_bus_default_system(ret);
3389 else if (STR_IN_SET(e, "user", "session"))
3390 return sd_bus_default_user(ret);
3393 /* No type is specified, so we have not other option than to
3394 * use the starter address if it is set. */
3396 e = secure_getenv("DBUS_STARTER_ADDRESS");
3398 static thread_local sd_bus *default_starter_bus = NULL;
3400 return bus_default(sd_bus_open, &default_starter_bus, ret);
3403 /* Finally, if nothing is set use the cached connection for
3404 * the right scope */
3406 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3407 return sd_bus_default_user(ret);
3409 return sd_bus_default_system(ret);
3412 /// UNNEEDED by elogind
3414 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3415 assert_return(b, -EINVAL);
3416 assert_return(tid, -EINVAL);
3417 assert_return(!bus_pid_changed(b), -ECHILD);
3425 return sd_event_get_tid(b->event, tid);
3430 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3431 _cleanup_free_ char *e = NULL;
3434 assert_return(object_path_is_valid(prefix), -EINVAL);
3435 assert_return(external_id, -EINVAL);
3436 assert_return(ret_path, -EINVAL);
3438 e = bus_label_escape(external_id);
3442 ret = strjoin(prefix, "/", e, NULL);
3450 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3454 assert_return(object_path_is_valid(path), -EINVAL);
3455 assert_return(object_path_is_valid(prefix), -EINVAL);
3456 assert_return(external_id, -EINVAL);
3458 e = object_path_startswith(path, prefix);
3460 *external_id = NULL;
3464 ret = bus_label_unescape(e);
3473 _public_ int sd_bus_try_close(sd_bus *bus) {
3476 assert_return(bus, -EINVAL);
3477 assert_return(!bus_pid_changed(bus), -ECHILD);
3479 if (!bus->is_kernel)
3482 if (!BUS_IS_OPEN(bus->state))
3485 if (bus->rqueue_size > 0)
3488 if (bus->wqueue_size > 0)
3491 r = bus_kernel_try_close(bus);
3499 /// UNNEEDED by elogind
3501 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3502 assert_return(bus, -EINVAL);
3503 assert_return(description, -EINVAL);
3504 assert_return(bus->description, -ENXIO);
3505 assert_return(!bus_pid_changed(bus), -ECHILD);
3507 *description = bus->description;
3512 int bus_get_root_path(sd_bus *bus) {
3515 if (bus->cgroup_root)
3518 r = cg_get_root_path(&bus->cgroup_root);
3520 bus->cgroup_root = strdup("/");
3521 if (!bus->cgroup_root)
3530 /// UNNEEDED by elogind
3532 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3535 assert_return(bus, -EINVAL);
3536 assert_return(scope, -EINVAL);
3537 assert_return(!bus_pid_changed(bus), -ECHILD);
3539 if (bus->is_kernel) {
3540 _cleanup_free_ char *n = NULL;
3543 r = bus_kernel_get_bus_name(bus, &n);
3547 if (streq(n, "0-system")) {
3552 dash = strchr(n, '-');
3553 if (streq_ptr(dash, "-user")) {
3564 if (bus->is_system) {
3572 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3574 assert_return(bus, -EINVAL);
3575 assert_return(address, -EINVAL);
3576 assert_return(!bus_pid_changed(bus), -ECHILD);
3579 *address = bus->address;
3586 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3587 assert_return(bus, -EINVAL);
3588 assert_return(mask, -EINVAL);
3589 assert_return(!bus_pid_changed(bus), -ECHILD);
3591 *mask = bus->creds_mask;
3595 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3596 assert_return(bus, -EINVAL);
3597 assert_return(!bus_pid_changed(bus), -ECHILD);
3599 return bus->bus_client;
3602 _public_ int sd_bus_is_server(sd_bus *bus) {
3603 assert_return(bus, -EINVAL);
3604 assert_return(!bus_pid_changed(bus), -ECHILD);
3606 return bus->is_server;
3609 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3610 assert_return(bus, -EINVAL);
3611 assert_return(!bus_pid_changed(bus), -ECHILD);
3613 return bus->anonymous_auth;
3616 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3617 assert_return(bus, -EINVAL);
3618 assert_return(!bus_pid_changed(bus), -ECHILD);
3620 return bus->trusted;
3623 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3624 assert_return(bus, -EINVAL);
3625 assert_return(!bus_pid_changed(bus), -ECHILD);
3627 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);