2 This file is part of systemd.
4 Copyright 2013 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
30 #include "alloc-util.h"
31 #include "bus-container.h"
32 #include "bus-control.h"
33 #include "bus-internal.h"
34 #include "bus-kernel.h"
35 #include "bus-label.h"
36 #include "bus-message.h"
37 #include "bus-objects.h"
38 #include "bus-protocol.h"
40 #include "bus-socket.h"
41 #include "bus-track.h"
44 #include "cgroup-util.h"
47 #include "hexdecoct.h"
48 #include "hostname-util.h"
51 #include "parse-util.h"
52 #include "string-util.h"
56 #define log_debug_bus_message(m) \
58 sd_bus_message *_mm = (m); \
59 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error-name=%s error-message=%s", \
60 bus_message_type_to_string(_mm->header->type), \
61 strna(sd_bus_message_get_sender(_mm)), \
62 strna(sd_bus_message_get_destination(_mm)), \
63 strna(sd_bus_message_get_path(_mm)), \
64 strna(sd_bus_message_get_interface(_mm)), \
65 strna(sd_bus_message_get_member(_mm)), \
66 BUS_MESSAGE_COOKIE(_mm), \
68 strna(_mm->error.name), \
69 strna(_mm->error.message)); \
72 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
73 static int attach_io_events(sd_bus *b);
74 static void detach_io_events(sd_bus *b);
76 static thread_local sd_bus *default_system_bus = NULL;
77 static thread_local sd_bus *default_user_bus = NULL;
78 static thread_local sd_bus *default_starter_bus = NULL;
80 static void bus_close_fds(sd_bus *b) {
85 if (b->input_fd != b->output_fd)
86 safe_close(b->output_fd);
87 b->output_fd = b->input_fd = safe_close(b->input_fd);
90 static void bus_reset_queues(sd_bus *b) {
93 while (b->rqueue_size > 0)
94 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
96 b->rqueue = mfree(b->rqueue);
97 b->rqueue_allocated = 0;
99 while (b->wqueue_size > 0)
100 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
102 b->wqueue = mfree(b->wqueue);
103 b->wqueue_allocated = 0;
106 static void bus_free(sd_bus *b) {
110 assert(!b->track_queue);
113 b->state = BUS_CLOSED;
115 sd_bus_detach_event(b);
117 while ((s = b->slots)) {
118 /* At this point only floating slots can still be
119 * around, because the non-floating ones keep a
120 * reference to the bus, and we thus couldn't be
121 * destructing right now... We forcibly disconnect the
122 * slots here, so that they still can be referenced by
123 * apps, but are dead. */
126 bus_slot_disconnect(s);
127 sd_bus_slot_unref(s);
130 if (b->default_bus_ptr)
131 *b->default_bus_ptr = NULL;
136 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
140 free(b->unique_name);
141 free(b->auth_buffer);
146 free(b->cgroup_root);
147 free(b->description);
150 strv_free(b->exec_argv);
152 close_many(b->fds, b->n_fds);
157 ordered_hashmap_free_free(b->reply_callbacks);
158 prioq_free(b->reply_callbacks_prioq);
160 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
161 bus_match_free(&b->match_callbacks);
163 hashmap_free_free(b->vtable_methods);
164 hashmap_free_free(b->vtable_properties);
166 assert(hashmap_isempty(b->nodes));
167 hashmap_free(b->nodes);
169 bus_kernel_flush_memfd(b);
171 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
176 _public_ int sd_bus_new(sd_bus **ret) {
179 assert_return(ret, -EINVAL);
185 r->n_ref = REFCNT_INIT;
186 r->input_fd = r->output_fd = -1;
187 r->message_version = 1;
188 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
189 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
190 r->attach_flags |= KDBUS_ATTACH_NAMES;
191 r->original_pid = getpid_cached();
193 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
195 /* We guarantee that wqueue always has space for at least one
197 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
206 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
209 assert_return(bus, -EINVAL);
210 assert_return(bus->state == BUS_UNSET, -EPERM);
211 assert_return(address, -EINVAL);
212 assert_return(!bus_pid_changed(bus), -ECHILD);
224 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
225 assert_return(bus, -EINVAL);
226 assert_return(bus->state == BUS_UNSET, -EPERM);
227 assert_return(input_fd >= 0, -EBADF);
228 assert_return(output_fd >= 0, -EBADF);
229 assert_return(!bus_pid_changed(bus), -ECHILD);
231 bus->input_fd = input_fd;
232 bus->output_fd = output_fd;
236 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
239 assert_return(bus, -EINVAL);
240 assert_return(bus->state == BUS_UNSET, -EPERM);
241 assert_return(path, -EINVAL);
242 assert_return(!strv_isempty(argv), -EINVAL);
243 assert_return(!bus_pid_changed(bus), -ECHILD);
255 free(bus->exec_path);
256 strv_free(bus->exec_argv);
264 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
265 assert_return(bus, -EINVAL);
266 assert_return(bus->state == BUS_UNSET, -EPERM);
267 assert_return(!bus_pid_changed(bus), -ECHILD);
269 bus->bus_client = !!b;
273 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
274 assert_return(bus, -EINVAL);
275 assert_return(bus->state == BUS_UNSET, -EPERM);
276 assert_return(!bus_pid_changed(bus), -ECHILD);
278 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
282 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
283 assert_return(bus, -EINVAL);
284 assert_return(bus->state == BUS_UNSET, -EPERM);
285 assert_return(!bus_pid_changed(bus), -ECHILD);
287 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
291 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
293 assert_return(bus, -EINVAL);
294 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
295 assert_return(!bus_pid_changed(bus), -ECHILD);
297 new_flags = bus->attach_flags;
298 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
300 if (bus->attach_flags == new_flags)
303 bus->attach_flags = new_flags;
304 if (bus->state != BUS_UNSET && bus->is_kernel)
305 bus_kernel_realize_attach_flags(bus);
310 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
313 assert_return(bus, -EINVAL);
314 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
315 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
316 assert_return(!bus_pid_changed(bus), -ECHILD);
318 SET_FLAG(bus->creds_mask, mask, b);
320 /* The well knowns we need unconditionally, so that matches can work */
321 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
323 /* Make sure we don't lose the timestamp flag */
324 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
325 if (bus->attach_flags == new_flags)
328 bus->attach_flags = new_flags;
329 if (bus->state != BUS_UNSET && bus->is_kernel)
330 bus_kernel_realize_attach_flags(bus);
335 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
336 assert_return(bus, -EINVAL);
337 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
338 assert_return(bus->state == BUS_UNSET, -EPERM);
339 assert_return(!bus_pid_changed(bus), -ECHILD);
341 bus->is_server = !!b;
342 bus->server_id = server_id;
346 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
347 assert_return(bus, -EINVAL);
348 assert_return(bus->state == BUS_UNSET, -EPERM);
349 assert_return(!bus_pid_changed(bus), -ECHILD);
351 bus->anonymous_auth = !!b;
355 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
356 assert_return(bus, -EINVAL);
357 assert_return(bus->state == BUS_UNSET, -EPERM);
358 assert_return(!bus_pid_changed(bus), -ECHILD);
364 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
365 assert_return(bus, -EINVAL);
366 assert_return(bus->state == BUS_UNSET, -EPERM);
367 assert_return(!bus_pid_changed(bus), -ECHILD);
369 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 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
381 assert_return(bus, -EINVAL);
382 assert_return(!bus_pid_changed(bus), -ECHILD);
384 return bus->allow_interactive_authorization;
387 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
395 assert(IN_SET(bus->state, BUS_HELLO, BUS_CLOSING));
397 r = sd_bus_message_get_errno(reply);
401 r = sd_bus_message_read(reply, "s", &s);
405 if (!service_name_is_valid(s) || s[0] != ':')
408 bus->unique_name = strdup(s);
409 if (!bus->unique_name)
412 if (bus->state == BUS_HELLO)
413 bus->state = BUS_RUNNING;
418 static int bus_send_hello(sd_bus *bus) {
419 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
424 if (!bus->bus_client || bus->is_kernel)
427 r = sd_bus_message_new_method_call(
430 "org.freedesktop.DBus",
431 "/org/freedesktop/DBus",
432 "org.freedesktop.DBus",
437 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
440 int bus_start_running(sd_bus *bus) {
443 if (bus->bus_client && !bus->is_kernel) {
444 bus->state = BUS_HELLO;
448 bus->state = BUS_RUNNING;
452 static int parse_address_key(const char **p, const char *key, char **value) {
453 size_t l, n = 0, allocated = 0;
463 if (strncmp(*p, key, l) != 0)
476 while (!IN_SET(*a, ';', ',', 0)) {
494 c = (char) ((x << 4) | y);
501 if (!GREEDY_REALLOC(r, allocated, n + 2))
525 static void skip_address_key(const char **p) {
529 *p += strcspn(*p, ",");
535 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
536 _cleanup_free_ char *path = NULL, *abstract = NULL;
545 while (!IN_SET(**p, 0, ';')) {
546 r = parse_address_key(p, "guid", guid);
552 r = parse_address_key(p, "path", &path);
558 r = parse_address_key(p, "abstract", &abstract);
567 if (!path && !abstract)
570 if (path && abstract)
575 if (l > sizeof(b->sockaddr.un.sun_path))
578 b->sockaddr.un.sun_family = AF_UNIX;
579 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
580 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
581 } else if (abstract) {
582 l = strlen(abstract);
583 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
586 b->sockaddr.un.sun_family = AF_UNIX;
587 b->sockaddr.un.sun_path[0] = 0;
588 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
589 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
597 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
598 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
600 struct addrinfo *result, hints = {
601 .ai_socktype = SOCK_STREAM,
602 .ai_flags = AI_ADDRCONFIG,
610 while (!IN_SET(**p, 0, ';')) {
611 r = parse_address_key(p, "guid", guid);
617 r = parse_address_key(p, "host", &host);
623 r = parse_address_key(p, "port", &port);
629 r = parse_address_key(p, "family", &family);
642 if (streq(family, "ipv4"))
643 hints.ai_family = AF_INET;
644 else if (streq(family, "ipv6"))
645 hints.ai_family = AF_INET6;
650 r = getaddrinfo(host, port, &hints, &result);
654 return -EADDRNOTAVAIL;
656 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
657 b->sockaddr_size = result->ai_addrlen;
659 freeaddrinfo(result);
666 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
668 unsigned n_argv = 0, j;
670 size_t allocated = 0;
678 while (!IN_SET(**p, 0, ';')) {
679 r = parse_address_key(p, "guid", guid);
685 r = parse_address_key(p, "path", &path);
691 if (startswith(*p, "argv")) {
695 ul = strtoul(*p + 4, (char**) p, 10);
696 if (errno > 0 || **p != '=' || ul > 256) {
704 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
712 r = parse_address_key(p, NULL, argv + ul);
727 /* Make sure there are no holes in the array, with the
728 * exception of argv[0] */
729 for (j = 1; j < n_argv; j++)
735 if (argv && argv[0] == NULL) {
736 argv[0] = strdup(path);
751 for (j = 0; j < n_argv; j++)
759 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
760 _cleanup_free_ char *path = NULL;
768 while (**p != 0 && **p != ';') {
769 r = parse_address_key(p, "guid", guid);
775 r = parse_address_key(p, "path", &path);
796 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
797 _cleanup_free_ char *machine = NULL, *pid = NULL;
805 while (!IN_SET(**p, 0, ';')) {
806 r = parse_address_key(p, "guid", guid);
812 r = parse_address_key(p, "machine", &machine);
818 r = parse_address_key(p, "pid", &pid);
827 if (!machine == !pid)
831 if (!machine_name_is_valid(machine))
835 b->machine = machine;
838 b->machine = mfree(b->machine);
842 r = parse_pid(pid, &b->nspid);
848 b->sockaddr.un.sun_family = AF_UNIX;
849 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
850 b->sockaddr_size = SOCKADDR_UN_LEN(b->sockaddr.un);
856 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
857 _cleanup_free_ char *machine = NULL, *pid = NULL;
865 while (**p != 0 && **p != ';') {
866 r = parse_address_key(p, "guid", guid);
872 r = parse_address_key(p, "machine", &machine);
878 r = parse_address_key(p, "pid", &pid);
887 if (!machine == !pid)
891 if (!machine_name_is_valid(machine))
895 b->machine = machine;
898 b->machine = mfree(b->machine);
902 r = parse_pid(pid, &b->nspid);
908 r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
917 static void bus_reset_parsed_address(sd_bus *b) {
921 b->sockaddr_size = 0;
922 b->exec_argv = strv_free(b->exec_argv);
923 b->exec_path = mfree(b->exec_path);
924 b->server_id = SD_ID128_NULL;
925 b->kernel = mfree(b->kernel);
926 b->machine = mfree(b->machine);
930 static int bus_parse_next_address(sd_bus *b) {
931 _cleanup_free_ char *guid = NULL;
939 if (b->address[b->address_index] == 0)
942 bus_reset_parsed_address(b);
944 a = b->address + b->address_index;
953 if (startswith(a, "unix:")) {
956 r = parse_unix_address(b, &a, &guid);
961 } else if (startswith(a, "tcp:")) {
964 r = parse_tcp_address(b, &a, &guid);
970 } else if (startswith(a, "unixexec:")) {
973 r = parse_exec_address(b, &a, &guid);
979 } else if (startswith(a, "kernel:")) {
982 r = parse_kernel_address(b, &a, &guid);
987 } else if (startswith(a, "x-machine-unix:")) {
990 r = parse_container_unix_address(b, &a, &guid);
995 } else if (startswith(a, "x-machine-kernel:")) {
998 r = parse_container_kernel_address(b, &a, &guid);
1011 r = sd_id128_from_string(guid, &b->server_id);
1016 b->address_index = a - b->address;
1020 static int bus_start_address(sd_bus *b) {
1021 bool container_kdbus_available = false;
1022 bool kdbus_available = false;
1028 bool skipped = false;
1033 * Usually, if you provide multiple different bus-addresses, we
1034 * try all of them in order. We use the first one that
1035 * succeeds. However, if you mix kernel and unix addresses, we
1036 * never try unix-addresses if a previous kernel address was
1037 * tried and kdbus was available. This is required to prevent
1038 * clients to fallback to the bus-proxy if kdbus is available
1039 * but failed (eg., too many connections).
1043 r = bus_socket_exec(b);
1044 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1045 r = bus_container_connect_kernel(b);
1046 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1047 container_kdbus_available = true;
1049 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1050 if (!container_kdbus_available)
1051 r = bus_container_connect_socket(b);
1055 } else if (b->kernel) {
1056 r = bus_kernel_connect(b);
1057 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1058 kdbus_available = true;
1060 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1061 if (!kdbus_available)
1062 r = bus_socket_connect(b);
1070 r = attach_io_events(b);
1075 b->last_connect_error = -r;
1078 r = bus_parse_next_address(b);
1082 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1086 int bus_next_address(sd_bus *b) {
1089 bus_reset_parsed_address(b);
1090 return bus_start_address(b);
1093 static int bus_start_fd(sd_bus *b) {
1098 assert(b->input_fd >= 0);
1099 assert(b->output_fd >= 0);
1101 r = fd_nonblock(b->input_fd, true);
1105 r = fd_cloexec(b->input_fd, true);
1109 if (b->input_fd != b->output_fd) {
1110 r = fd_nonblock(b->output_fd, true);
1114 r = fd_cloexec(b->output_fd, true);
1119 if (fstat(b->input_fd, &st) < 0)
1122 if (S_ISCHR(b->input_fd))
1123 return bus_kernel_take_fd(b);
1125 return bus_socket_take_fd(b);
1128 _public_ int sd_bus_start(sd_bus *bus) {
1131 assert_return(bus, -EINVAL);
1132 assert_return(bus->state == BUS_UNSET, -EPERM);
1133 assert_return(!bus_pid_changed(bus), -ECHILD);
1135 bus->state = BUS_OPENING;
1137 if (bus->is_server && bus->bus_client)
1140 if (bus->input_fd >= 0)
1141 r = bus_start_fd(bus);
1142 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1143 r = bus_start_address(bus);
1152 return bus_send_hello(bus);
1155 _public_ int sd_bus_open(sd_bus **ret) {
1160 assert_return(ret, -EINVAL);
1162 /* Let's connect to the starter bus if it is set, and
1163 * otherwise to the bus that is appropropriate for the scope
1164 * we are running in */
1166 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1168 if (streq(e, "system"))
1169 return sd_bus_open_system(ret);
1170 else if (STR_IN_SET(e, "session", "user"))
1171 return sd_bus_open_user(ret);
1174 e = secure_getenv("DBUS_STARTER_ADDRESS");
1176 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1177 return sd_bus_open_user(ret);
1179 return sd_bus_open_system(ret);
1186 r = sd_bus_set_address(b, e);
1190 b->bus_client = true;
1192 /* We don't know whether the bus is trusted or not, so better
1193 * be safe, and authenticate everything */
1195 b->is_local = false;
1196 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1197 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1199 r = sd_bus_start(b);
1211 int bus_set_address_system(sd_bus *b) {
1215 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1217 return sd_bus_set_address(b, e);
1219 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1222 _public_ int sd_bus_open_system(sd_bus **ret) {
1226 assert_return(ret, -EINVAL);
1232 r = bus_set_address_system(b);
1236 b->bus_client = true;
1237 b->is_system = true;
1239 /* Let's do per-method access control on the system bus. We
1240 * need the caller's UID and capability set for that. */
1242 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1243 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1246 r = sd_bus_start(b);
1258 int bus_set_address_user(sd_bus *b) {
1265 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1267 return sd_bus_set_address(b, e);
1269 r = cg_pid_get_owner_uid(0, &uid);
1273 e = secure_getenv("XDG_RUNTIME_DIR");
1275 _cleanup_free_ char *ee = NULL;
1277 ee = bus_address_escape(e);
1281 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1283 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1291 _public_ int sd_bus_open_user(sd_bus **ret) {
1295 assert_return(ret, -EINVAL);
1301 r = bus_set_address_user(b);
1305 b->bus_client = true;
1308 /* We don't do any per-method access control on the user
1313 r = sd_bus_start(b);
1325 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1326 _cleanup_free_ char *e = NULL;
1327 char *m = NULL, *c = NULL;
1332 /* Let's see if we shall enter some container */
1333 m = strchr(host, ':');
1337 /* Let's make sure this is not a port of some kind,
1338 * and is a valid machine name. */
1339 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1342 /* Cut out the host part */
1343 t = strndupa(host, m - host - 1);
1344 e = bus_address_escape(t);
1348 c = strjoina(",argv5=--machine=", m);
1353 e = bus_address_escape(host);
1358 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=systemd-stdio-bridge", c);
1365 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1369 assert_return(host, -EINVAL);
1370 assert_return(ret, -EINVAL);
1372 r = sd_bus_new(&bus);
1376 r = bus_set_address_system_remote(bus, host);
1380 bus->bus_client = true;
1381 bus->trusted = false;
1382 bus->is_system = true;
1383 bus->is_local = false;
1385 r = sd_bus_start(bus);
1397 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1398 _cleanup_free_ char *e = NULL;
1403 e = bus_address_escape(machine);
1407 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e);
1414 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1418 assert_return(machine, -EINVAL);
1419 assert_return(ret, -EINVAL);
1420 assert_return(machine_name_is_valid(machine), -EINVAL);
1422 r = sd_bus_new(&bus);
1426 r = bus_set_address_system_machine(bus, machine);
1430 bus->bus_client = true;
1431 bus->trusted = false;
1432 bus->is_system = true;
1433 bus->is_local = false;
1435 r = sd_bus_start(bus);
1447 _public_ void sd_bus_close(sd_bus *bus) {
1451 if (bus->state == BUS_CLOSED)
1453 if (bus_pid_changed(bus))
1456 bus->state = BUS_CLOSED;
1458 sd_bus_detach_event(bus);
1460 /* Drop all queued messages so that they drop references to
1461 * the bus object and the bus may be freed */
1462 bus_reset_queues(bus);
1464 if (!bus->is_kernel)
1467 /* We'll leave the fd open in case this is a kernel bus, since
1468 * there might still be memblocks around that reference this
1469 * bus, and they might need to invoke the KDBUS_CMD_FREE
1470 * ioctl on the fd when they are freed. */
1473 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1481 return sd_bus_unref(bus);
1484 static void bus_enter_closing(sd_bus *bus) {
1487 if (!IN_SET(bus->state, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1490 bus->state = BUS_CLOSING;
1493 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1498 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1503 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1509 i = REFCNT_DEC(bus->n_ref);
1517 _public_ int sd_bus_is_open(sd_bus *bus) {
1519 assert_return(bus, -EINVAL);
1520 assert_return(!bus_pid_changed(bus), -ECHILD);
1522 return BUS_IS_OPEN(bus->state);
1525 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1528 assert_return(bus, -EINVAL);
1529 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1530 assert_return(!bus_pid_changed(bus), -ECHILD);
1532 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1535 if (type == SD_BUS_TYPE_UNIX_FD) {
1536 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1539 r = bus_ensure_running(bus);
1543 return bus->can_fds;
1546 return bus_type_is_valid(type);
1549 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1552 assert_return(bus, -EINVAL);
1553 assert_return(id, -EINVAL);
1554 assert_return(!bus_pid_changed(bus), -ECHILD);
1556 r = bus_ensure_running(bus);
1560 *id = bus->server_id;
1564 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1569 /* If we copy the same message to multiple
1570 * destinations, avoid using the same cookie
1572 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1577 timeout = BUS_DEFAULT_TIMEOUT;
1579 return bus_message_seal(m, ++b->cookie, timeout);
1582 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1583 bool remarshal = false;
1587 /* wrong packet version */
1588 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1591 /* wrong packet endianness */
1592 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1595 /* TODO: kdbus-messages received from the kernel contain data which is
1596 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1597 * force remarshaling of the message. Technically, we could just
1598 * recreate the kdbus message, but that is non-trivial as other parts of
1599 * the message refer to m->kdbus already. This should be fixed! */
1600 if ((*m)->kdbus && (*m)->release_kdbus)
1603 return remarshal ? bus_message_remarshal(b, m) : 0;
1606 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1610 /* Fake some timestamps, if they were requested, and not
1611 * already initialized */
1612 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1613 if (m->realtime <= 0)
1614 m->realtime = now(CLOCK_REALTIME);
1616 if (m->monotonic <= 0)
1617 m->monotonic = now(CLOCK_MONOTONIC);
1620 /* The bus specification says the serial number cannot be 0,
1621 * hence let's fill something in for synthetic messages. Since
1622 * synthetic messages might have a fake sender and we don't
1623 * want to interfere with the real sender's serial numbers we
1624 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1625 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1626 * even though kdbus can do 64bit. */
1627 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1630 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1637 r = bus_kernel_write_message(bus, m, hint_sync_call);
1639 r = bus_socket_write_message(bus, m, idx);
1644 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1645 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error-name=%s error-message=%s",
1646 bus_message_type_to_string(m->header->type),
1647 strna(sd_bus_message_get_sender(m)),
1648 strna(sd_bus_message_get_destination(m)),
1649 strna(sd_bus_message_get_path(m)),
1650 strna(sd_bus_message_get_interface(m)),
1651 strna(sd_bus_message_get_member(m)),
1652 BUS_MESSAGE_COOKIE(m),
1654 strna(m->error.name),
1655 strna(m->error.message));
1660 static int dispatch_wqueue(sd_bus *bus) {
1664 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1666 while (bus->wqueue_size > 0) {
1668 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1672 /* Didn't do anything this time */
1674 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1675 /* Fully written. Let's drop the entry from
1678 * This isn't particularly optimized, but
1679 * well, this is supposed to be our worst-case
1680 * buffer only, and the socket buffer is
1681 * supposed to be our primary buffer, and if
1682 * it got full, then all bets are off
1686 sd_bus_message_unref(bus->wqueue[0]);
1687 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1697 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1701 return bus_kernel_read_message(bus, hint_priority, priority);
1703 return bus_socket_read_message(bus);
1706 int bus_rqueue_make_room(sd_bus *bus) {
1709 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1712 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1718 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1723 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1725 /* Note that the priority logic is only available on kdbus,
1726 * where the rqueue is unused. We check the rqueue here
1727 * anyway, because it's simple... */
1730 if (bus->rqueue_size > 0) {
1731 /* Dispatch a queued message */
1733 *m = bus->rqueue[0];
1735 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1739 /* Try to read a new message */
1740 r = bus_read_message(bus, hint_priority, priority);
1750 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1751 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1754 assert_return(m, -EINVAL);
1759 assert_return(!bus_pid_changed(bus), -ECHILD);
1760 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1762 if (!BUS_IS_OPEN(bus->state))
1766 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1773 /* If the cookie number isn't kept, then we know that no reply
1775 if (!cookie && !m->sealed)
1776 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1778 r = bus_seal_message(bus, m, 0);
1782 /* Remarshall if we have to. This will possibly unref the
1783 * message and place a replacement in m */
1784 r = bus_remarshal_message(bus, &m);
1788 /* If this is a reply and no reply was requested, then let's
1789 * suppress this, if we can */
1793 if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1796 r = bus_write_message(bus, m, hint_sync_call, &idx);
1798 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1799 bus_enter_closing(bus);
1806 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1807 /* Wasn't fully written. So let's remember how
1808 * much was written. Note that the first entry
1809 * of the wqueue array is always allocated so
1810 * that we always can remember how much was
1812 bus->wqueue[0] = sd_bus_message_ref(m);
1813 bus->wqueue_size = 1;
1818 /* Just append it to the queue. */
1820 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1823 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1826 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1831 *cookie = BUS_MESSAGE_COOKIE(m);
1836 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1837 return bus_send_internal(bus, m, cookie, false);
1840 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1843 assert_return(m, -EINVAL);
1848 assert_return(!bus_pid_changed(bus), -ECHILD);
1850 if (!BUS_IS_OPEN(bus->state))
1853 if (!streq_ptr(m->destination, destination)) {
1858 r = sd_bus_message_set_destination(m, destination);
1863 return sd_bus_send(bus, m, cookie);
1866 static usec_t calc_elapse(uint64_t usec) {
1867 if (usec == (uint64_t) -1)
1870 return now(CLOCK_MONOTONIC) + usec;
1873 static int timeout_compare(const void *a, const void *b) {
1874 const struct reply_callback *x = a, *y = b;
1876 if (x->timeout != 0 && y->timeout == 0)
1879 if (x->timeout == 0 && y->timeout != 0)
1882 if (x->timeout < y->timeout)
1885 if (x->timeout > y->timeout)
1891 _public_ int sd_bus_call_async(
1895 sd_bus_message_handler_t callback,
1899 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1900 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1903 assert_return(m, -EINVAL);
1904 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1905 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1906 assert_return(callback, -EINVAL);
1911 assert_return(!bus_pid_changed(bus), -ECHILD);
1912 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1914 if (!BUS_IS_OPEN(bus->state))
1917 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1921 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1925 r = bus_seal_message(bus, m, usec);
1929 r = bus_remarshal_message(bus, &m);
1933 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1937 s->reply_callback.callback = callback;
1939 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1940 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1942 s->reply_callback.cookie = 0;
1946 s->reply_callback.timeout = calc_elapse(m->timeout);
1947 if (s->reply_callback.timeout != 0) {
1948 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1950 s->reply_callback.timeout = 0;
1955 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1966 int bus_ensure_running(sd_bus *bus) {
1971 if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
1973 if (bus->state == BUS_RUNNING)
1977 r = sd_bus_process(bus, NULL);
1980 if (bus->state == BUS_RUNNING)
1985 r = sd_bus_wait(bus, (uint64_t) -1);
1991 _public_ int sd_bus_call(
1995 sd_bus_error *error,
1996 sd_bus_message **reply) {
1998 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
2004 bus_assert_return(m, -EINVAL, error);
2005 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2006 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2007 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2012 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2013 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2015 if (!BUS_IS_OPEN(bus->state)) {
2020 r = bus_ensure_running(bus);
2024 i = bus->rqueue_size;
2026 r = bus_seal_message(bus, m, usec);
2030 r = bus_remarshal_message(bus, &m);
2034 r = bus_send_internal(bus, m, &cookie, true);
2038 timeout = calc_elapse(m->timeout);
2043 while (i < bus->rqueue_size) {
2044 sd_bus_message *incoming = NULL;
2046 incoming = bus->rqueue[i];
2048 if (incoming->reply_cookie == cookie) {
2049 /* Found a match! */
2051 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2053 log_debug_bus_message(incoming);
2055 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2057 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2061 sd_bus_message_unref(incoming);
2066 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2067 sd_bus_message_unref(incoming);
2070 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2071 r = sd_bus_error_copy(error, &incoming->error);
2072 sd_bus_message_unref(incoming);
2079 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2082 streq(bus->unique_name, incoming->sender)) {
2084 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2087 /* Our own message? Somebody is trying
2088 * to send its own client a message,
2089 * let's not dead-lock, let's fail
2092 sd_bus_message_unref(incoming);
2097 /* Try to read more, right-away */
2101 r = bus_read_message(bus, false, 0);
2103 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2104 bus_enter_closing(bus);
2116 n = now(CLOCK_MONOTONIC);
2124 left = (uint64_t) -1;
2126 r = bus_poll(bus, true, left);
2134 r = dispatch_wqueue(bus);
2136 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2137 bus_enter_closing(bus);
2146 return sd_bus_error_set_errno(error, r);
2149 _public_ int sd_bus_get_fd(sd_bus *bus) {
2151 assert_return(bus, -EINVAL);
2152 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2153 assert_return(!bus_pid_changed(bus), -ECHILD);
2155 return bus->input_fd;
2158 _public_ int sd_bus_get_events(sd_bus *bus) {
2161 assert_return(bus, -EINVAL);
2162 assert_return(!bus_pid_changed(bus), -ECHILD);
2164 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2167 if (bus->state == BUS_OPENING)
2169 else if (bus->state == BUS_AUTHENTICATING) {
2171 if (bus_socket_auth_needs_write(bus))
2176 } else if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO)) {
2177 if (bus->rqueue_size <= 0)
2179 if (bus->wqueue_size > 0)
2186 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2187 struct reply_callback *c;
2189 assert_return(bus, -EINVAL);
2190 assert_return(timeout_usec, -EINVAL);
2191 assert_return(!bus_pid_changed(bus), -ECHILD);
2193 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2196 if (bus->track_queue) {
2201 if (bus->state == BUS_CLOSING) {
2206 if (bus->state == BUS_AUTHENTICATING) {
2207 *timeout_usec = bus->auth_timeout;
2211 if (!IN_SET(bus->state, BUS_RUNNING, BUS_HELLO)) {
2212 *timeout_usec = (uint64_t) -1;
2216 if (bus->rqueue_size > 0) {
2221 c = prioq_peek(bus->reply_callbacks_prioq);
2223 *timeout_usec = (uint64_t) -1;
2227 if (c->timeout == 0) {
2228 *timeout_usec = (uint64_t) -1;
2232 *timeout_usec = c->timeout;
2236 static int process_timeout(sd_bus *bus) {
2237 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2238 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2239 struct reply_callback *c;
2246 c = prioq_peek(bus->reply_callbacks_prioq);
2250 n = now(CLOCK_MONOTONIC);
2254 r = bus_message_new_synthetic_error(
2257 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2262 r = bus_seal_synthetic_message(bus, m);
2266 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2269 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2272 slot = container_of(c, sd_bus_slot, reply_callback);
2274 bus->iteration_counter++;
2276 bus->current_message = m;
2277 bus->current_slot = sd_bus_slot_ref(slot);
2278 bus->current_handler = c->callback;
2279 bus->current_userdata = slot->userdata;
2280 r = c->callback(m, slot->userdata, &error_buffer);
2281 bus->current_userdata = NULL;
2282 bus->current_handler = NULL;
2283 bus->current_slot = NULL;
2284 bus->current_message = NULL;
2286 if (slot->floating) {
2287 bus_slot_disconnect(slot);
2288 sd_bus_slot_unref(slot);
2291 sd_bus_slot_unref(slot);
2293 return bus_maybe_reply_error(m, r, &error_buffer);
2296 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2300 if (bus->state != BUS_HELLO)
2303 /* Let's make sure the first message on the bus is the HELLO
2304 * reply. But note that we don't actually parse the message
2305 * here (we leave that to the usual handling), we just verify
2306 * we don't let any earlier msg through. */
2308 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2311 if (m->reply_cookie != 1)
2317 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2318 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2319 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2320 struct reply_callback *c;
2327 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2330 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2333 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2336 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2342 slot = container_of(c, sd_bus_slot, reply_callback);
2344 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2346 /* If the reply contained a file descriptor which we
2347 * didn't want we pass an error instead. */
2349 r = bus_message_new_synthetic_error(
2352 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2357 /* Copy over original timestamp */
2358 synthetic_reply->realtime = m->realtime;
2359 synthetic_reply->monotonic = m->monotonic;
2360 synthetic_reply->seqnum = m->seqnum;
2362 r = bus_seal_synthetic_message(bus, synthetic_reply);
2366 m = synthetic_reply;
2368 r = sd_bus_message_rewind(m, true);
2373 if (c->timeout != 0) {
2374 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2378 bus->current_slot = sd_bus_slot_ref(slot);
2379 bus->current_handler = c->callback;
2380 bus->current_userdata = slot->userdata;
2381 r = c->callback(m, slot->userdata, &error_buffer);
2382 bus->current_userdata = NULL;
2383 bus->current_handler = NULL;
2384 bus->current_slot = NULL;
2386 if (slot->floating) {
2387 bus_slot_disconnect(slot);
2388 sd_bus_slot_unref(slot);
2391 sd_bus_slot_unref(slot);
2393 return bus_maybe_reply_error(m, r, &error_buffer);
2396 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2397 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2398 struct filter_callback *l;
2405 bus->filter_callbacks_modified = false;
2407 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2410 if (bus->filter_callbacks_modified)
2413 /* Don't run this more than once per iteration */
2414 if (l->last_iteration == bus->iteration_counter)
2417 l->last_iteration = bus->iteration_counter;
2419 r = sd_bus_message_rewind(m, true);
2423 slot = container_of(l, sd_bus_slot, filter_callback);
2425 bus->current_slot = sd_bus_slot_ref(slot);
2426 bus->current_handler = l->callback;
2427 bus->current_userdata = slot->userdata;
2428 r = l->callback(m, slot->userdata, &error_buffer);
2429 bus->current_userdata = NULL;
2430 bus->current_handler = NULL;
2431 bus->current_slot = sd_bus_slot_unref(slot);
2433 r = bus_maybe_reply_error(m, r, &error_buffer);
2439 } while (bus->filter_callbacks_modified);
2444 static int process_match(sd_bus *bus, sd_bus_message *m) {
2451 bus->match_callbacks_modified = false;
2453 r = bus_match_run(bus, &bus->match_callbacks, m);
2457 } while (bus->match_callbacks_modified);
2462 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2463 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2469 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2472 if (bus->manual_peer_interface)
2475 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2478 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2481 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2484 if (streq_ptr(m->member, "Ping"))
2485 r = sd_bus_message_new_method_return(m, &reply);
2486 else if (streq_ptr(m->member, "GetMachineId")) {
2490 r = sd_id128_get_machine(&id);
2494 r = sd_bus_message_new_method_return(m, &reply);
2498 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2500 r = sd_bus_message_new_method_errorf(
2502 SD_BUS_ERROR_UNKNOWN_METHOD,
2503 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2509 r = sd_bus_send(bus, reply, NULL);
2516 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2520 /* If we got a message with a file descriptor which we didn't
2521 * want to accept, then let's drop it. How can this even
2522 * happen? For example, when the kernel queues a message into
2523 * an activatable names's queue which allows fds, and then is
2524 * delivered to us later even though we ourselves did not
2527 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2533 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2536 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2537 return 1; /* just eat it up */
2539 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2542 static int process_message(sd_bus *bus, sd_bus_message *m) {
2548 bus->current_message = m;
2549 bus->iteration_counter++;
2551 log_debug_bus_message(m);
2553 r = process_hello(bus, m);
2557 r = process_reply(bus, m);
2561 r = process_fd_check(bus, m);
2565 r = process_filter(bus, m);
2569 r = process_match(bus, m);
2573 r = process_builtin(bus, m);
2577 r = bus_process_object(bus, m);
2580 bus->current_message = NULL;
2584 static int dispatch_track(sd_bus *bus) {
2587 if (!bus->track_queue)
2590 bus_track_dispatch(bus->track_queue);
2594 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2595 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2599 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2601 r = process_timeout(bus);
2605 r = dispatch_wqueue(bus);
2609 r = dispatch_track(bus);
2613 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2619 r = process_message(bus, m);
2624 r = sd_bus_message_rewind(m, true);
2633 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2635 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2636 strna(sd_bus_message_get_sender(m)),
2637 strna(sd_bus_message_get_path(m)),
2638 strna(sd_bus_message_get_interface(m)),
2639 strna(sd_bus_message_get_member(m)));
2641 r = sd_bus_reply_method_errorf(
2643 SD_BUS_ERROR_UNKNOWN_OBJECT,
2644 "Unknown object '%s'.", m->path);
2658 static int bus_exit_now(sd_bus *bus) {
2661 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2662 * sd_event_exit(), otherwise invokes libc exit(). */
2664 if (bus->exited) /* did we already exit? */
2666 if (!bus->exit_triggered) /* was the exit condition triggered? */
2668 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2671 bus->exited = true; /* never exit more than once */
2673 log_debug("Bus connection disconnected, exiting.");
2676 return sd_event_exit(bus->event, EXIT_FAILURE);
2680 assert_not_reached("exit() didn't exit?");
2683 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2684 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2685 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2692 r = bus_message_new_synthetic_error(
2695 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2700 r = bus_seal_synthetic_message(bus, m);
2704 if (c->timeout != 0) {
2705 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2709 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2712 slot = container_of(c, sd_bus_slot, reply_callback);
2714 bus->iteration_counter++;
2716 bus->current_message = m;
2717 bus->current_slot = sd_bus_slot_ref(slot);
2718 bus->current_handler = c->callback;
2719 bus->current_userdata = slot->userdata;
2720 r = c->callback(m, slot->userdata, &error_buffer);
2721 bus->current_userdata = NULL;
2722 bus->current_handler = NULL;
2723 bus->current_slot = NULL;
2724 bus->current_message = NULL;
2726 if (slot->floating) {
2727 bus_slot_disconnect(slot);
2728 sd_bus_slot_unref(slot);
2731 sd_bus_slot_unref(slot);
2733 return bus_maybe_reply_error(m, r, &error_buffer);
2736 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2737 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2738 struct reply_callback *c;
2742 assert(bus->state == BUS_CLOSING);
2744 /* First, fail all outstanding method calls */
2745 c = ordered_hashmap_first(bus->reply_callbacks);
2747 return process_closing_reply_callback(bus, c);
2749 /* Then, fake-drop all remaining bus tracking references */
2751 bus_track_close(bus->tracks);
2755 /* Then, synthesize a Disconnected message */
2756 r = sd_bus_message_new_signal(
2759 "/org/freedesktop/DBus/Local",
2760 "org.freedesktop.DBus.Local",
2765 bus_message_set_sender_local(bus, m);
2767 r = bus_seal_synthetic_message(bus, m);
2773 bus->current_message = m;
2774 bus->iteration_counter++;
2776 r = process_filter(bus, m);
2780 r = process_match(bus, m);
2784 /* Nothing else to do, exit now, if the condition holds */
2785 bus->exit_triggered = true;
2786 (void) bus_exit_now(bus);
2796 bus->current_message = NULL;
2801 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2802 BUS_DONT_DESTROY(bus);
2805 /* Returns 0 when we didn't do anything. This should cause the
2806 * caller to invoke sd_bus_wait() before returning the next
2807 * time. Returns > 0 when we did something, which possibly
2808 * means *ret is filled in with an unprocessed message. */
2810 assert_return(bus, -EINVAL);
2811 assert_return(!bus_pid_changed(bus), -ECHILD);
2813 /* We don't allow recursively invoking sd_bus_process(). */
2814 assert_return(!bus->current_message, -EBUSY);
2815 assert(!bus->current_slot);
2817 switch (bus->state) {
2826 r = bus_socket_process_opening(bus);
2827 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2828 bus_enter_closing(bus);
2836 case BUS_AUTHENTICATING:
2837 r = bus_socket_process_authenticating(bus);
2838 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2839 bus_enter_closing(bus);
2851 r = process_running(bus, hint_priority, priority, ret);
2852 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2853 bus_enter_closing(bus);
2863 return process_closing(bus, ret);
2866 assert_not_reached("Unknown state");
2869 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2870 return bus_process_internal(bus, false, 0, ret);
2873 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2874 return bus_process_internal(bus, true, priority, ret);
2877 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2878 struct pollfd p[2] = {};
2881 usec_t m = USEC_INFINITY;
2885 if (bus->state == BUS_CLOSING)
2888 if (!BUS_IS_OPEN(bus->state))
2891 e = sd_bus_get_events(bus);
2896 /* The caller really needs some more data, he doesn't
2897 * care about what's already read, or any timeouts
2898 * except its own. */
2902 /* The caller wants to process if there's something to
2903 * process, but doesn't care otherwise */
2905 r = sd_bus_get_timeout(bus, &until);
2910 nw = now(CLOCK_MONOTONIC);
2911 m = until > nw ? until - nw : 0;
2915 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2918 p[0].fd = bus->input_fd;
2919 if (bus->output_fd == bus->input_fd) {
2923 p[0].events = e & POLLIN;
2924 p[1].fd = bus->output_fd;
2925 p[1].events = e & POLLOUT;
2929 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2933 return r > 0 ? 1 : 0;
2936 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2938 assert_return(bus, -EINVAL);
2939 assert_return(!bus_pid_changed(bus), -ECHILD);
2941 if (bus->state == BUS_CLOSING)
2944 if (!BUS_IS_OPEN(bus->state))
2947 if (bus->rqueue_size > 0)
2950 return bus_poll(bus, false, timeout_usec);
2953 _public_ int sd_bus_flush(sd_bus *bus) {
2956 assert_return(bus, -EINVAL);
2957 assert_return(!bus_pid_changed(bus), -ECHILD);
2959 if (bus->state == BUS_CLOSING)
2962 if (!BUS_IS_OPEN(bus->state))
2965 r = bus_ensure_running(bus);
2969 if (bus->wqueue_size <= 0)
2973 r = dispatch_wqueue(bus);
2975 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2976 bus_enter_closing(bus);
2983 if (bus->wqueue_size <= 0)
2986 r = bus_poll(bus, false, (uint64_t) -1);
2992 _public_ int sd_bus_add_filter(
2995 sd_bus_message_handler_t callback,
3000 assert_return(bus, -EINVAL);
3001 assert_return(callback, -EINVAL);
3002 assert_return(!bus_pid_changed(bus), -ECHILD);
3004 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
3008 s->filter_callback.callback = callback;
3010 bus->filter_callbacks_modified = true;
3011 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
3019 _public_ int sd_bus_add_match(
3023 sd_bus_message_handler_t callback,
3026 struct bus_match_component *components = NULL;
3027 unsigned n_components = 0;
3028 sd_bus_slot *s = NULL;
3031 assert_return(bus, -EINVAL);
3032 assert_return(match, -EINVAL);
3033 assert_return(!bus_pid_changed(bus), -ECHILD);
3035 r = bus_match_parse(match, &components, &n_components);
3039 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3045 s->match_callback.callback = callback;
3047 if (bus->bus_client) {
3048 enum bus_match_scope scope;
3050 scope = bus_match_get_scope(components, n_components);
3052 /* Do not install server-side matches for matches
3053 * against the local service, interface or bus
3055 if (scope != BUS_MATCH_LOCAL) {
3057 if (!bus->is_kernel) {
3058 /* When this is not a kernel transport, we
3059 * store the original match string, so that we
3060 * can use it to remove the match again */
3062 s->match_callback.match_string = strdup(match);
3063 if (!s->match_callback.match_string) {
3069 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components);
3073 s->match_added = true;
3077 bus->match_callbacks_modified = true;
3078 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3087 bus_match_parse_free(components, n_components);
3088 sd_bus_slot_unref(s);
3093 int bus_remove_match_by_string(
3096 sd_bus_message_handler_t callback,
3099 struct bus_match_component *components = NULL;
3100 unsigned n_components = 0;
3101 struct match_callback *c;
3104 assert_return(bus, -EINVAL);
3105 assert_return(match, -EINVAL);
3106 assert_return(!bus_pid_changed(bus), -ECHILD);
3108 r = bus_match_parse(match, &components, &n_components);
3112 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3116 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3119 bus_match_parse_free(components, n_components);
3124 bool bus_pid_changed(sd_bus *bus) {
3127 /* We don't support people creating a bus connection and
3128 * keeping it around over a fork(). Let's complain. */
3130 return bus->original_pid != getpid_cached();
3133 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3134 sd_bus *bus = userdata;
3139 r = sd_bus_process(bus, NULL);
3146 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3147 sd_bus *bus = userdata;
3152 r = sd_bus_process(bus, NULL);
3159 static int prepare_callback(sd_event_source *s, void *userdata) {
3160 sd_bus *bus = userdata;
3167 e = sd_bus_get_events(bus);
3171 if (bus->output_fd != bus->input_fd) {
3173 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3177 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3181 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3186 r = sd_bus_get_timeout(bus, &until);
3192 j = sd_event_source_set_time(bus->time_event_source, until);
3197 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3204 static int quit_callback(sd_event_source *event, void *userdata) {
3205 sd_bus *bus = userdata;
3215 static int attach_io_events(sd_bus *bus) {
3220 if (bus->input_fd < 0)
3226 if (!bus->input_io_event_source) {
3227 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3231 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3235 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3239 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3241 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3246 if (bus->output_fd != bus->input_fd) {
3247 assert(bus->output_fd >= 0);
3249 if (!bus->output_io_event_source) {
3250 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3254 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3258 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3260 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3269 static void detach_io_events(sd_bus *bus) {
3272 if (bus->input_io_event_source) {
3273 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3274 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3277 if (bus->output_io_event_source) {
3278 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3279 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3283 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3286 assert_return(bus, -EINVAL);
3287 assert_return(!bus->event, -EBUSY);
3289 assert(!bus->input_io_event_source);
3290 assert(!bus->output_io_event_source);
3291 assert(!bus->time_event_source);
3294 bus->event = sd_event_ref(event);
3296 r = sd_event_default(&bus->event);
3301 bus->event_priority = priority;
3303 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3307 r = sd_event_source_set_priority(bus->time_event_source, priority);
3311 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3315 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3319 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3323 r = attach_io_events(bus);
3330 sd_bus_detach_event(bus);
3334 _public_ int sd_bus_detach_event(sd_bus *bus) {
3335 assert_return(bus, -EINVAL);
3340 detach_io_events(bus);
3342 if (bus->time_event_source) {
3343 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3344 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3347 if (bus->quit_event_source) {
3348 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3349 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3352 bus->event = sd_event_unref(bus->event);
3356 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3357 assert_return(bus, NULL);
3362 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3363 assert_return(bus, NULL);
3365 return bus->current_message;
3368 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3369 assert_return(bus, NULL);
3371 return bus->current_slot;
3374 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3375 assert_return(bus, NULL);
3377 return bus->current_handler;
3380 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3381 assert_return(bus, NULL);
3383 return bus->current_userdata;
3386 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3391 assert(default_bus);
3394 return !!*default_bus;
3397 *ret = sd_bus_ref(*default_bus);
3405 b->default_bus_ptr = default_bus;
3413 _public_ int sd_bus_default_system(sd_bus **ret) {
3414 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3418 _public_ int sd_bus_default_user(sd_bus **ret) {
3419 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3422 _public_ int sd_bus_default(sd_bus **ret) {
3426 /* Let's try our best to reuse another cached connection. If
3427 * the starter bus type is set, connect via our normal
3428 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3429 * we can share the connection with the user/system default
3432 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3434 if (streq(e, "system"))
3435 return sd_bus_default_system(ret);
3436 else if (STR_IN_SET(e, "user", "session"))
3437 return sd_bus_default_user(ret);
3440 /* No type is specified, so we have not other option than to
3441 * use the starter address if it is set. */
3443 e = secure_getenv("DBUS_STARTER_ADDRESS");
3446 return bus_default(sd_bus_open, &default_starter_bus, ret);
3449 /* Finally, if nothing is set use the cached connection for
3450 * the right scope */
3452 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3453 return sd_bus_default_user(ret);
3455 return sd_bus_default_system(ret);
3458 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3459 assert_return(b, -EINVAL);
3460 assert_return(tid, -EINVAL);
3461 assert_return(!bus_pid_changed(b), -ECHILD);
3469 return sd_event_get_tid(b->event, tid);
3474 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3475 _cleanup_free_ char *e = NULL;
3478 assert_return(object_path_is_valid(prefix), -EINVAL);
3479 assert_return(external_id, -EINVAL);
3480 assert_return(ret_path, -EINVAL);
3482 e = bus_label_escape(external_id);
3486 ret = strjoin(prefix, "/", e);
3494 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3498 assert_return(object_path_is_valid(path), -EINVAL);
3499 assert_return(object_path_is_valid(prefix), -EINVAL);
3500 assert_return(external_id, -EINVAL);
3502 e = object_path_startswith(path, prefix);
3504 *external_id = NULL;
3508 ret = bus_label_unescape(e);
3516 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3517 _cleanup_strv_free_ char **labels = NULL;
3518 char *path, *path_pos, **label_pos;
3519 const char *sep, *template_pos;
3524 assert_return(out, -EINVAL);
3525 assert_return(path_template, -EINVAL);
3527 path_length = strlen(path_template);
3529 va_start(list, path_template);
3530 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3534 arg = va_arg(list, const char *);
3540 label = bus_label_escape(arg);
3546 r = strv_consume(&labels, label);
3552 /* add label length, but account for the format character */
3553 path_length += strlen(label) - 1;
3557 path = malloc(path_length + 1);
3564 for (template_pos = path_template; *template_pos; ) {
3565 sep = strchrnul(template_pos, '%');
3566 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3570 path_pos = stpcpy(path_pos, *label_pos++);
3571 template_pos = sep + 1;
3579 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3580 _cleanup_strv_free_ char **labels = NULL;
3581 const char *template_pos, *path_pos;
3587 * This decodes an object-path based on a template argument. The
3588 * template consists of a verbatim path, optionally including special
3591 * - Each occurrence of '%' in the template matches an arbitrary
3592 * substring of a label in the given path. At most one such
3593 * directive is allowed per label. For each such directive, the
3594 * caller must provide an output parameter (char **) via va_arg. If
3595 * NULL is passed, the given label is verified, but not returned.
3596 * For each matched label, the *decoded* label is stored in the
3597 * passed output argument, and the caller is responsible to free
3598 * it. Note that the output arguments are only modified if the
3599 * actualy path matched the template. Otherwise, they're left
3602 * This function returns <0 on error, 0 if the path does not match the
3603 * template, 1 if it matched.
3606 assert_return(path, -EINVAL);
3607 assert_return(path_template, -EINVAL);
3611 for (template_pos = path_template; *template_pos; ) {
3616 /* verify everything until the next '%' matches verbatim */
3617 sep = strchrnul(template_pos, '%');
3618 length = sep - template_pos;
3619 if (strncmp(path_pos, template_pos, length))
3623 template_pos += length;
3628 /* We found the next '%' character. Everything up until here
3629 * matched. We now skip ahead to the end of this label and make
3630 * sure it matches the tail of the label in the path. Then we
3631 * decode the string in-between and save it for later use. */
3633 ++template_pos; /* skip over '%' */
3635 sep = strchrnul(template_pos, '/');
3636 length = sep - template_pos; /* length of suffix to match verbatim */
3638 /* verify the suffixes match */
3639 sep = strchrnul(path_pos, '/');
3640 if (sep - path_pos < (ssize_t)length ||
3641 strncmp(sep - length, template_pos, length))
3644 template_pos += length; /* skip over matched label */
3645 length = sep - path_pos - length; /* length of sub-label to decode */
3647 /* store unescaped label for later use */
3648 label = bus_label_unescape_n(path_pos, length);
3652 r = strv_consume(&labels, label);
3656 path_pos = sep; /* skip decoded label and suffix */
3659 /* end of template must match end of path */
3663 /* copy the labels over to the caller */
3664 va_start(list, path_template);
3665 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3668 arg = va_arg(list, char **);
3681 _public_ int sd_bus_try_close(sd_bus *bus) {
3684 assert_return(bus, -EINVAL);
3685 assert_return(!bus_pid_changed(bus), -ECHILD);
3687 if (!bus->is_kernel)
3690 if (!BUS_IS_OPEN(bus->state))
3693 if (bus->rqueue_size > 0)
3696 if (bus->wqueue_size > 0)
3699 r = bus_kernel_try_close(bus);
3707 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3708 assert_return(bus, -EINVAL);
3709 assert_return(description, -EINVAL);
3710 assert_return(bus->description, -ENXIO);
3711 assert_return(!bus_pid_changed(bus), -ECHILD);
3713 *description = bus->description;
3717 int bus_get_root_path(sd_bus *bus) {
3720 if (bus->cgroup_root)
3723 r = cg_get_root_path(&bus->cgroup_root);
3725 bus->cgroup_root = strdup("/");
3726 if (!bus->cgroup_root)
3735 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3738 assert_return(bus, -EINVAL);
3739 assert_return(scope, -EINVAL);
3740 assert_return(!bus_pid_changed(bus), -ECHILD);
3742 if (bus->is_kernel) {
3743 _cleanup_free_ char *n = NULL;
3746 r = bus_kernel_get_bus_name(bus, &n);
3750 if (streq(n, "0-system")) {
3755 dash = strchr(n, '-');
3756 if (streq_ptr(dash, "-user")) {
3767 if (bus->is_system) {
3775 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3777 assert_return(bus, -EINVAL);
3778 assert_return(address, -EINVAL);
3779 assert_return(!bus_pid_changed(bus), -ECHILD);
3782 *address = bus->address;
3789 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3790 assert_return(bus, -EINVAL);
3791 assert_return(mask, -EINVAL);
3792 assert_return(!bus_pid_changed(bus), -ECHILD);
3794 *mask = bus->creds_mask;
3798 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3799 assert_return(bus, -EINVAL);
3800 assert_return(!bus_pid_changed(bus), -ECHILD);
3802 return bus->bus_client;
3805 _public_ int sd_bus_is_server(sd_bus *bus) {
3806 assert_return(bus, -EINVAL);
3807 assert_return(!bus_pid_changed(bus), -ECHILD);
3809 return bus->is_server;
3812 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3813 assert_return(bus, -EINVAL);
3814 assert_return(!bus_pid_changed(bus), -ECHILD);
3816 return bus->anonymous_auth;
3819 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3820 assert_return(bus, -EINVAL);
3821 assert_return(!bus_pid_changed(bus), -ECHILD);
3823 return bus->trusted;
3826 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3827 assert_return(bus, -EINVAL);
3828 assert_return(!bus_pid_changed(bus), -ECHILD);
3830 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3833 static void flush_close(sd_bus *bus) {
3837 /* Flushes and closes the specified bus. We take a ref before,
3838 * to ensure the flushing does not cause the bus to be
3841 sd_bus_flush_close_unref(sd_bus_ref(bus));
3844 _public_ void sd_bus_default_flush_close(void) {
3845 flush_close(default_starter_bus);
3846 flush_close(default_user_bus);
3847 flush_close(default_system_bus);
3850 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
3851 assert_return(bus, -EINVAL);
3853 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
3854 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
3855 * from the client side. */
3856 bus->exit_on_disconnect = b;
3858 /* If the exit condition was triggered already, exit immediately. */
3859 return bus_exit_now(bus);
3862 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
3863 assert_return(bus, -EINVAL);
3865 return bus->exit_on_disconnect;