1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
31 #include "alloc-util.h"
32 #include "bus-container.h"
33 #include "bus-control.h"
34 #include "bus-internal.h"
35 #include "bus-kernel.h"
36 #include "bus-label.h"
37 #include "bus-message.h"
38 #include "bus-objects.h"
39 #include "bus-protocol.h"
41 #include "bus-socket.h"
42 #include "bus-track.h"
45 #include "cgroup-util.h"
48 #include "hexdecoct.h"
49 #include "hostname-util.h"
52 #include "parse-util.h"
53 #include "string-util.h"
57 /// Additional includes needed by elogind
58 #include "process-util.h"
60 #define log_debug_bus_message(m) \
62 sd_bus_message *_mm = (m); \
63 log_debug("Got message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s", \
64 bus_message_type_to_string(_mm->header->type), \
65 strna(sd_bus_message_get_sender(_mm)), \
66 strna(sd_bus_message_get_destination(_mm)), \
67 strna(sd_bus_message_get_path(_mm)), \
68 strna(sd_bus_message_get_interface(_mm)), \
69 strna(sd_bus_message_get_member(_mm)), \
70 BUS_MESSAGE_COOKIE(_mm), \
72 strna(_mm->root_container.signature), \
73 strna(_mm->error.name), \
74 strna(_mm->error.message)); \
77 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
78 static void bus_detach_io_events(sd_bus *b);
79 static void bus_detach_inotify_event(sd_bus *b);
81 static thread_local sd_bus *default_system_bus = NULL;
82 #if 0 /// UNNEEDED by elogind
83 static thread_local sd_bus *default_user_bus = NULL;
85 static thread_local sd_bus *default_starter_bus = NULL;
87 void bus_close_io_fds(sd_bus *b) {
90 bus_detach_io_events(b);
92 if (b->input_fd != b->output_fd)
93 safe_close(b->output_fd);
94 b->output_fd = b->input_fd = safe_close(b->input_fd);
97 void bus_close_inotify_fd(sd_bus *b) {
100 bus_detach_inotify_event(b);
102 b->inotify_fd = safe_close(b->inotify_fd);
103 b->inotify_watches = mfree(b->inotify_watches);
104 b->n_inotify_watches = 0;
107 static void bus_reset_queues(sd_bus *b) {
110 while (b->rqueue_size > 0)
111 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
113 b->rqueue = mfree(b->rqueue);
114 b->rqueue_allocated = 0;
116 while (b->wqueue_size > 0)
117 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
119 b->wqueue = mfree(b->wqueue);
120 b->wqueue_allocated = 0;
123 static void bus_free(sd_bus *b) {
127 assert(!b->track_queue);
130 b->state = BUS_CLOSED;
132 sd_bus_detach_event(b);
134 while ((s = b->slots)) {
135 /* At this point only floating slots can still be
136 * around, because the non-floating ones keep a
137 * reference to the bus, and we thus couldn't be
138 * destructing right now... We forcibly disconnect the
139 * slots here, so that they still can be referenced by
140 * apps, but are dead. */
143 bus_slot_disconnect(s);
144 sd_bus_slot_unref(s);
147 if (b->default_bus_ptr)
148 *b->default_bus_ptr = NULL;
151 bus_close_inotify_fd(b);
156 free(b->unique_name);
157 free(b->auth_buffer);
160 free(b->cgroup_root);
161 free(b->description);
164 strv_free(b->exec_argv);
166 close_many(b->fds, b->n_fds);
171 ordered_hashmap_free_free(b->reply_callbacks);
172 prioq_free(b->reply_callbacks_prioq);
174 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
175 bus_match_free(&b->match_callbacks);
177 hashmap_free_free(b->vtable_methods);
178 hashmap_free_free(b->vtable_properties);
180 assert(hashmap_isempty(b->nodes));
181 hashmap_free(b->nodes);
185 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
190 _public_ int sd_bus_new(sd_bus **ret) {
193 assert_return(ret, -EINVAL);
199 r->n_ref = REFCNT_INIT;
200 r->input_fd = r->output_fd = -1;
202 r->message_version = 1;
203 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
205 r->original_pid = getpid_cached();
206 r->n_groups = (size_t) -1;
208 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
210 /* We guarantee that wqueue always has space for at least one
212 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
221 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
224 assert_return(bus, -EINVAL);
225 assert_return(bus->state == BUS_UNSET, -EPERM);
226 assert_return(address, -EINVAL);
227 assert_return(!bus_pid_changed(bus), -ECHILD);
239 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
240 assert_return(bus, -EINVAL);
241 assert_return(bus->state == BUS_UNSET, -EPERM);
242 assert_return(input_fd >= 0, -EBADF);
243 assert_return(output_fd >= 0, -EBADF);
244 assert_return(!bus_pid_changed(bus), -ECHILD);
246 bus->input_fd = input_fd;
247 bus->output_fd = output_fd;
251 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
254 assert_return(bus, -EINVAL);
255 assert_return(bus->state == BUS_UNSET, -EPERM);
256 assert_return(path, -EINVAL);
257 assert_return(!strv_isempty(argv), -EINVAL);
258 assert_return(!bus_pid_changed(bus), -ECHILD);
270 free(bus->exec_path);
271 strv_free(bus->exec_argv);
279 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
280 assert_return(bus, -EINVAL);
281 assert_return(bus->state == BUS_UNSET, -EPERM);
282 assert_return(!bus_pid_changed(bus), -ECHILD);
284 bus->bus_client = !!b;
288 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
289 assert_return(bus, -EINVAL);
290 assert_return(bus->state == BUS_UNSET, -EPERM);
291 assert_return(!bus_pid_changed(bus), -ECHILD);
297 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
298 assert_return(bus, -EINVAL);
299 assert_return(bus->state == BUS_UNSET, -EPERM);
300 assert_return(!bus_pid_changed(bus), -ECHILD);
306 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
307 assert_return(bus, -EINVAL);
308 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
309 assert_return(!bus_pid_changed(bus), -ECHILD);
311 /* This is not actually supported by any of our transports these days, but we do honour it for synthetic
312 * replies, and maybe one day classic D-Bus learns this too */
313 bus->attach_timestamp = b;
318 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
319 assert_return(bus, -EINVAL);
320 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
321 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
322 assert_return(!bus_pid_changed(bus), -ECHILD);
324 SET_FLAG(bus->creds_mask, mask, b);
326 /* The well knowns we need unconditionally, so that matches can work */
327 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
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 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
344 assert_return(bus, -EINVAL);
345 assert_return(bus->state == BUS_UNSET, -EPERM);
346 assert_return(!bus_pid_changed(bus), -ECHILD);
348 bus->anonymous_auth = !!b;
352 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
353 assert_return(bus, -EINVAL);
354 assert_return(bus->state == BUS_UNSET, -EPERM);
355 assert_return(!bus_pid_changed(bus), -ECHILD);
361 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
362 assert_return(bus, -EINVAL);
363 assert_return(bus->state == BUS_UNSET, -EPERM);
364 assert_return(!bus_pid_changed(bus), -ECHILD);
366 return free_and_strdup(&bus->description, description);
369 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
370 assert_return(bus, -EINVAL);
371 assert_return(!bus_pid_changed(bus), -ECHILD);
373 bus->allow_interactive_authorization = !!b;
377 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
378 assert_return(bus, -EINVAL);
379 assert_return(!bus_pid_changed(bus), -ECHILD);
381 return bus->allow_interactive_authorization;
384 _public_ int sd_bus_set_watch_bind(sd_bus *bus, int b) {
385 assert_return(bus, -EINVAL);
386 assert_return(bus->state == BUS_UNSET, -EPERM);
387 assert_return(!bus_pid_changed(bus), -ECHILD);
393 _public_ int sd_bus_get_watch_bind(sd_bus *bus) {
394 assert_return(bus, -EINVAL);
395 assert_return(!bus_pid_changed(bus), -ECHILD);
397 return bus->watch_bind;
400 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
408 assert(IN_SET(bus->state, BUS_HELLO, BUS_CLOSING));
410 r = sd_bus_message_get_errno(reply);
414 r = sd_bus_message_read(reply, "s", &s);
418 if (!service_name_is_valid(s) || s[0] != ':')
421 bus->unique_name = strdup(s);
422 if (!bus->unique_name)
425 if (bus->state == BUS_HELLO)
426 bus->state = BUS_RUNNING;
431 static int bus_send_hello(sd_bus *bus) {
432 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
437 if (!bus->bus_client)
440 r = sd_bus_message_new_method_call(
443 "org.freedesktop.DBus",
444 "/org/freedesktop/DBus",
445 "org.freedesktop.DBus",
450 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
453 int bus_start_running(sd_bus *bus) {
454 struct reply_callback *c;
459 assert(bus->state < BUS_HELLO);
461 /* We start all method call timeouts when we enter BUS_HELLO or BUS_RUNNING mode. At this point let's convert
462 * all relative to absolute timestamps. Note that we do not reshuffle the reply callback priority queue since
463 * adding a fixed value to all entries should not alter the internal order. */
465 n = now(CLOCK_MONOTONIC);
466 ORDERED_HASHMAP_FOREACH(c, bus->reply_callbacks, i) {
467 if (c->timeout_usec == 0)
470 c->timeout_usec = usec_add(n, c->timeout_usec);
473 if (bus->bus_client) {
474 bus->state = BUS_HELLO;
478 bus->state = BUS_RUNNING;
482 static int parse_address_key(const char **p, const char *key, char **value) {
483 size_t l, n = 0, allocated = 0;
493 if (strncmp(*p, key, l) != 0)
506 while (!IN_SET(*a, ';', ',', 0)) {
524 c = (char) ((x << 4) | y);
531 if (!GREEDY_REALLOC(r, allocated, n + 2))
555 static void skip_address_key(const char **p) {
559 *p += strcspn(*p, ",");
565 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
566 _cleanup_free_ char *path = NULL, *abstract = NULL;
575 while (!IN_SET(**p, 0, ';')) {
576 r = parse_address_key(p, "guid", guid);
582 r = parse_address_key(p, "path", &path);
588 r = parse_address_key(p, "abstract", &abstract);
597 if (!path && !abstract)
600 if (path && abstract)
605 if (l > sizeof(b->sockaddr.un.sun_path))
608 b->sockaddr.un.sun_family = AF_UNIX;
609 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
610 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
611 } else if (abstract) {
612 l = strlen(abstract);
613 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
616 b->sockaddr.un.sun_family = AF_UNIX;
617 b->sockaddr.un.sun_path[0] = 0;
618 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
619 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
627 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
628 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
630 struct addrinfo *result, hints = {
631 .ai_socktype = SOCK_STREAM,
632 .ai_flags = AI_ADDRCONFIG,
640 while (!IN_SET(**p, 0, ';')) {
641 r = parse_address_key(p, "guid", guid);
647 r = parse_address_key(p, "host", &host);
653 r = parse_address_key(p, "port", &port);
659 r = parse_address_key(p, "family", &family);
672 if (streq(family, "ipv4"))
673 hints.ai_family = AF_INET;
674 else if (streq(family, "ipv6"))
675 hints.ai_family = AF_INET6;
680 r = getaddrinfo(host, port, &hints, &result);
684 return -EADDRNOTAVAIL;
686 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
687 b->sockaddr_size = result->ai_addrlen;
689 freeaddrinfo(result);
696 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
698 unsigned n_argv = 0, j;
700 size_t allocated = 0;
708 while (!IN_SET(**p, 0, ';')) {
709 r = parse_address_key(p, "guid", guid);
715 r = parse_address_key(p, "path", &path);
721 if (startswith(*p, "argv")) {
725 ul = strtoul(*p + 4, (char**) p, 10);
726 if (errno > 0 || **p != '=' || ul > 256) {
734 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
742 r = parse_address_key(p, NULL, argv + ul);
757 /* Make sure there are no holes in the array, with the
758 * exception of argv[0] */
759 for (j = 1; j < n_argv; j++)
765 if (argv && argv[0] == NULL) {
766 argv[0] = strdup(path);
781 for (j = 0; j < n_argv; j++)
789 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
790 _cleanup_free_ char *machine = NULL, *pid = NULL;
798 while (!IN_SET(**p, 0, ';')) {
799 r = parse_address_key(p, "guid", guid);
805 r = parse_address_key(p, "machine", &machine);
811 r = parse_address_key(p, "pid", &pid);
820 if (!machine == !pid)
824 if (!machine_name_is_valid(machine))
827 free_and_replace(b->machine, machine);
829 b->machine = mfree(b->machine);
833 r = parse_pid(pid, &b->nspid);
839 b->sockaddr.un.sun_family = AF_UNIX;
840 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
841 b->sockaddr_size = SOCKADDR_UN_LEN(b->sockaddr.un);
847 static void bus_reset_parsed_address(sd_bus *b) {
851 b->sockaddr_size = 0;
852 b->exec_argv = strv_free(b->exec_argv);
853 b->exec_path = mfree(b->exec_path);
854 b->server_id = SD_ID128_NULL;
855 b->machine = mfree(b->machine);
859 static int bus_parse_next_address(sd_bus *b) {
860 _cleanup_free_ char *guid = NULL;
868 if (b->address[b->address_index] == 0)
871 bus_reset_parsed_address(b);
873 a = b->address + b->address_index;
882 if (startswith(a, "unix:")) {
885 r = parse_unix_address(b, &a, &guid);
890 } else if (startswith(a, "tcp:")) {
893 r = parse_tcp_address(b, &a, &guid);
899 } else if (startswith(a, "unixexec:")) {
902 r = parse_exec_address(b, &a, &guid);
908 } else if (startswith(a, "x-machine-unix:")) {
911 r = parse_container_unix_address(b, &a, &guid);
924 r = sd_id128_from_string(guid, &b->server_id);
929 b->address_index = a - b->address;
933 static int bus_start_address(sd_bus *b) {
940 bus_close_inotify_fd(b);
942 /* If you provide multiple different bus-addresses, we
943 * try all of them in order and use the first one that
947 r = bus_socket_exec(b);
948 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
949 r = bus_container_connect_socket(b);
950 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
951 r = bus_socket_connect(b);
958 q = bus_attach_io_events(b);
962 q = bus_attach_inotify_event(b);
969 b->last_connect_error = -r;
972 r = bus_parse_next_address(b);
976 return b->last_connect_error > 0 ? -b->last_connect_error : -ECONNREFUSED;
980 int bus_next_address(sd_bus *b) {
983 bus_reset_parsed_address(b);
984 return bus_start_address(b);
987 static int bus_start_fd(sd_bus *b) {
992 assert(b->input_fd >= 0);
993 assert(b->output_fd >= 0);
995 r = fd_nonblock(b->input_fd, true);
999 r = fd_cloexec(b->input_fd, true);
1003 if (b->input_fd != b->output_fd) {
1004 r = fd_nonblock(b->output_fd, true);
1008 r = fd_cloexec(b->output_fd, true);
1013 if (fstat(b->input_fd, &st) < 0)
1016 return bus_socket_take_fd(b);
1019 _public_ int sd_bus_start(sd_bus *bus) {
1022 assert_return(bus, -EINVAL);
1023 assert_return(bus->state == BUS_UNSET, -EPERM);
1024 assert_return(!bus_pid_changed(bus), -ECHILD);
1026 bus->state = BUS_OPENING;
1028 if (bus->is_server && bus->bus_client)
1031 if (bus->input_fd >= 0)
1032 r = bus_start_fd(bus);
1033 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->machine)
1034 r = bus_start_address(bus);
1043 return bus_send_hello(bus);
1046 _public_ int sd_bus_open(sd_bus **ret) {
1051 assert_return(ret, -EINVAL);
1053 /* Let's connect to the starter bus if it is set, and
1054 * otherwise to the bus that is appropropriate for the scope
1055 * we are running in */
1057 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1059 if (streq(e, "system"))
1060 return sd_bus_open_system(ret);
1061 #if 0 /// elogind does not support systemd user instances
1062 else if (STR_IN_SET(e, "session", "user"))
1063 return sd_bus_open_user(ret);
1067 e = secure_getenv("DBUS_STARTER_ADDRESS");
1069 #if 0 /// elogind does not support systemd user instances
1070 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1071 return sd_bus_open_user(ret);
1074 return sd_bus_open_system(ret);
1081 r = sd_bus_set_address(b, e);
1085 b->bus_client = true;
1087 /* We don't know whether the bus is trusted or not, so better
1088 * be safe, and authenticate everything */
1090 b->is_local = false;
1091 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1093 r = sd_bus_start(b);
1105 int bus_set_address_system(sd_bus *b) {
1109 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1111 return sd_bus_set_address(b, e);
1113 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1116 _public_ int sd_bus_open_system(sd_bus **ret) {
1120 assert_return(ret, -EINVAL);
1126 r = bus_set_address_system(b);
1130 b->bus_client = true;
1131 b->is_system = true;
1133 /* Let's do per-method access control on the system bus. We
1134 * need the caller's UID and capability set for that. */
1136 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1139 r = sd_bus_start(b);
1151 #if 0 /// elogind can not open/use a user bus
1152 int bus_set_address_user(sd_bus *b) {
1154 _cleanup_free_ char *ee = NULL, *s = NULL;
1158 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1160 return sd_bus_set_address(b, e);
1162 e = secure_getenv("XDG_RUNTIME_DIR");
1166 ee = bus_address_escape(e);
1170 if (asprintf(&s, UNIX_USER_BUS_ADDRESS_FMT, ee) < 0)
1180 _public_ int sd_bus_open_user(sd_bus **ret) {
1181 #if 0 /// elogind does not support user buses
1185 assert_return(ret, -EINVAL);
1191 r = bus_set_address_user(b);
1195 b->bus_client = true;
1198 /* We don't do any per-method access control on the user
1203 r = sd_bus_start(b);
1214 return sd_bus_open_system(ret);
1218 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1219 _cleanup_free_ char *e = NULL;
1220 char *m = NULL, *c = NULL;
1225 /* Let's see if we shall enter some container */
1226 m = strchr(host, ':');
1230 /* Let's make sure this is not a port of some kind,
1231 * and is a valid machine name. */
1232 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1235 /* Cut out the host part */
1236 t = strndupa(host, m - host - 1);
1237 e = bus_address_escape(t);
1241 c = strjoina(",argv5=--machine=", m);
1246 e = bus_address_escape(host);
1251 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=systemd-stdio-bridge", c);
1258 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1262 assert_return(host, -EINVAL);
1263 assert_return(ret, -EINVAL);
1265 r = sd_bus_new(&bus);
1269 r = bus_set_address_system_remote(bus, host);
1273 bus->bus_client = true;
1274 bus->trusted = false;
1275 bus->is_system = true;
1276 bus->is_local = false;
1278 r = sd_bus_start(bus);
1290 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1291 _cleanup_free_ char *e = NULL;
1296 e = bus_address_escape(machine);
1300 b->address = strjoin("x-machine-unix:machine=", e);
1307 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1311 assert_return(machine, -EINVAL);
1312 assert_return(ret, -EINVAL);
1313 assert_return(machine_name_is_valid(machine), -EINVAL);
1315 r = sd_bus_new(&bus);
1319 r = bus_set_address_system_machine(bus, machine);
1323 bus->bus_client = true;
1324 bus->trusted = false;
1325 bus->is_system = true;
1326 bus->is_local = false;
1328 r = sd_bus_start(bus);
1340 _public_ void sd_bus_close(sd_bus *bus) {
1344 if (bus->state == BUS_CLOSED)
1346 if (bus_pid_changed(bus))
1349 bus->state = BUS_CLOSED;
1351 sd_bus_detach_event(bus);
1353 /* Drop all queued messages so that they drop references to
1354 * the bus object and the bus may be freed */
1355 bus_reset_queues(bus);
1357 bus_close_io_fds(bus);
1358 bus_close_inotify_fd(bus);
1361 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1369 return sd_bus_unref(bus);
1372 static void bus_enter_closing(sd_bus *bus) {
1375 if (!IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1378 bus->state = BUS_CLOSING;
1381 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1386 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1391 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1397 i = REFCNT_DEC(bus->n_ref);
1405 _public_ int sd_bus_is_open(sd_bus *bus) {
1407 assert_return(bus, -EINVAL);
1408 assert_return(!bus_pid_changed(bus), -ECHILD);
1410 return BUS_IS_OPEN(bus->state);
1413 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1416 assert_return(bus, -EINVAL);
1417 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1418 assert_return(!bus_pid_changed(bus), -ECHILD);
1420 if (bus->is_monitor)
1423 if (type == SD_BUS_TYPE_UNIX_FD) {
1424 if (!bus->accept_fd)
1427 r = bus_ensure_running(bus);
1431 return bus->can_fds;
1434 return bus_type_is_valid(type);
1437 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1440 assert_return(bus, -EINVAL);
1441 assert_return(id, -EINVAL);
1442 assert_return(!bus_pid_changed(bus), -ECHILD);
1444 r = bus_ensure_running(bus);
1448 *id = bus->server_id;
1452 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1457 /* If we copy the same message to multiple
1458 * destinations, avoid using the same cookie
1460 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1465 timeout = BUS_DEFAULT_TIMEOUT;
1467 return sd_bus_message_seal(m, ++b->cookie, timeout);
1470 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1471 bool remarshal = false;
1475 /* wrong packet version */
1476 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1479 /* wrong packet endianness */
1480 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1483 return remarshal ? bus_message_remarshal(b, m) : 0;
1486 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1490 /* Fake some timestamps, if they were requested, and not
1491 * already initialized */
1492 if (b->attach_timestamp) {
1493 if (m->realtime <= 0)
1494 m->realtime = now(CLOCK_REALTIME);
1496 if (m->monotonic <= 0)
1497 m->monotonic = now(CLOCK_MONOTONIC);
1500 /* The bus specification says the serial number cannot be 0,
1501 * hence let's fill something in for synthetic messages. Since
1502 * synthetic messages might have a fake sender and we don't
1503 * want to interfere with the real sender's serial numbers we
1504 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1505 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1506 * even though kdbus can do 64bit. */
1507 return sd_bus_message_seal(m, 0xFFFFFFFFULL, 0);
1510 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1516 r = bus_socket_write_message(bus, m, idx);
1520 if (*idx >= BUS_MESSAGE_SIZE(m))
1521 log_debug("Sent message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s",
1522 bus_message_type_to_string(m->header->type),
1523 strna(sd_bus_message_get_sender(m)),
1524 strna(sd_bus_message_get_destination(m)),
1525 strna(sd_bus_message_get_path(m)),
1526 strna(sd_bus_message_get_interface(m)),
1527 strna(sd_bus_message_get_member(m)),
1528 BUS_MESSAGE_COOKIE(m),
1530 strna(m->root_container.signature),
1531 strna(m->error.name),
1532 strna(m->error.message));
1537 static int dispatch_wqueue(sd_bus *bus) {
1541 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1543 while (bus->wqueue_size > 0) {
1545 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1549 /* Didn't do anything this time */
1551 else if (bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1552 /* Fully written. Let's drop the entry from
1555 * This isn't particularly optimized, but
1556 * well, this is supposed to be our worst-case
1557 * buffer only, and the socket buffer is
1558 * supposed to be our primary buffer, and if
1559 * it got full, then all bets are off
1563 sd_bus_message_unref(bus->wqueue[0]);
1564 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1574 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1577 return bus_socket_read_message(bus);
1580 int bus_rqueue_make_room(sd_bus *bus) {
1583 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1586 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1592 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1597 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1599 /* Note that the priority logic is only available on kdbus,
1600 * where the rqueue is unused. We check the rqueue here
1601 * anyway, because it's simple... */
1604 if (bus->rqueue_size > 0) {
1605 /* Dispatch a queued message */
1607 *m = bus->rqueue[0];
1609 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1613 /* Try to read a new message */
1614 r = bus_read_message(bus, hint_priority, priority);
1624 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1625 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1628 assert_return(m, -EINVAL);
1633 assert_return(!bus_pid_changed(bus), -ECHILD);
1635 if (!BUS_IS_OPEN(bus->state))
1639 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1646 /* If the cookie number isn't kept, then we know that no reply
1648 if (!cookie && !m->sealed)
1649 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1651 r = bus_seal_message(bus, m, 0);
1655 /* Remarshall if we have to. This will possibly unref the
1656 * message and place a replacement in m */
1657 r = bus_remarshal_message(bus, &m);
1661 /* If this is a reply and no reply was requested, then let's
1662 * suppress this, if we can */
1666 if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1669 r = bus_write_message(bus, m, hint_sync_call, &idx);
1671 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1672 bus_enter_closing(bus);
1679 if (idx < BUS_MESSAGE_SIZE(m)) {
1680 /* Wasn't fully written. So let's remember how
1681 * much was written. Note that the first entry
1682 * of the wqueue array is always allocated so
1683 * that we always can remember how much was
1685 bus->wqueue[0] = sd_bus_message_ref(m);
1686 bus->wqueue_size = 1;
1691 /* Just append it to the queue. */
1693 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1696 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1699 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1704 *cookie = BUS_MESSAGE_COOKIE(m);
1709 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1710 return bus_send_internal(bus, m, cookie, false);
1713 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1716 assert_return(m, -EINVAL);
1721 assert_return(!bus_pid_changed(bus), -ECHILD);
1723 if (!BUS_IS_OPEN(bus->state))
1726 if (!streq_ptr(m->destination, destination)) {
1731 r = sd_bus_message_set_destination(m, destination);
1736 return sd_bus_send(bus, m, cookie);
1739 static usec_t calc_elapse(sd_bus *bus, uint64_t usec) {
1742 if (usec == (uint64_t) -1)
1745 /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1746 * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1747 * relative timestamp, and afterwards the absolute one. */
1749 if (IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING))
1752 return now(CLOCK_MONOTONIC) + usec;
1755 static int timeout_compare(const void *a, const void *b) {
1756 const struct reply_callback *x = a, *y = b;
1758 if (x->timeout_usec != 0 && y->timeout_usec == 0)
1761 if (x->timeout_usec == 0 && y->timeout_usec != 0)
1764 if (x->timeout_usec < y->timeout_usec)
1767 if (x->timeout_usec > y->timeout_usec)
1773 _public_ int sd_bus_call_async(
1777 sd_bus_message_handler_t callback,
1781 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1782 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1785 assert_return(m, -EINVAL);
1786 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1787 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1788 assert_return(callback, -EINVAL);
1793 assert_return(!bus_pid_changed(bus), -ECHILD);
1795 if (!BUS_IS_OPEN(bus->state))
1798 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1802 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1806 r = bus_seal_message(bus, m, usec);
1810 r = bus_remarshal_message(bus, &m);
1814 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1818 s->reply_callback.callback = callback;
1820 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1821 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1823 s->reply_callback.cookie = 0;
1827 s->reply_callback.timeout_usec = calc_elapse(bus, m->timeout);
1828 if (s->reply_callback.timeout_usec != 0) {
1829 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1831 s->reply_callback.timeout_usec = 0;
1836 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1847 int bus_ensure_running(sd_bus *bus) {
1852 if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
1854 if (bus->state == BUS_RUNNING)
1858 r = sd_bus_process(bus, NULL);
1861 if (bus->state == BUS_RUNNING)
1866 r = sd_bus_wait(bus, (uint64_t) -1);
1872 _public_ int sd_bus_call(
1876 sd_bus_error *error,
1877 sd_bus_message **reply) {
1879 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1885 bus_assert_return(m, -EINVAL, error);
1886 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
1887 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
1888 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
1893 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
1895 if (!BUS_IS_OPEN(bus->state)) {
1900 r = bus_ensure_running(bus);
1904 i = bus->rqueue_size;
1906 r = bus_seal_message(bus, m, usec);
1910 r = bus_remarshal_message(bus, &m);
1914 r = bus_send_internal(bus, m, &cookie, true);
1918 timeout = calc_elapse(bus, m->timeout);
1923 while (i < bus->rqueue_size) {
1924 sd_bus_message *incoming = NULL;
1926 incoming = bus->rqueue[i];
1928 if (incoming->reply_cookie == cookie) {
1929 /* Found a match! */
1931 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1933 log_debug_bus_message(incoming);
1935 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1937 if (incoming->n_fds <= 0 || bus->accept_fd) {
1941 sd_bus_message_unref(incoming);
1946 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1947 sd_bus_message_unref(incoming);
1950 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
1951 r = sd_bus_error_copy(error, &incoming->error);
1952 sd_bus_message_unref(incoming);
1959 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1962 streq(bus->unique_name, incoming->sender)) {
1964 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1967 /* Our own message? Somebody is trying
1968 * to send its own client a message,
1969 * let's not dead-lock, let's fail
1972 sd_bus_message_unref(incoming);
1977 /* Try to read more, right-away */
1981 r = bus_read_message(bus, false, 0);
1983 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1984 bus_enter_closing(bus);
1996 n = now(CLOCK_MONOTONIC);
2004 left = (uint64_t) -1;
2006 r = bus_poll(bus, true, left);
2014 r = dispatch_wqueue(bus);
2016 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2017 bus_enter_closing(bus);
2026 return sd_bus_error_set_errno(error, r);
2029 _public_ int sd_bus_get_fd(sd_bus *bus) {
2031 assert_return(bus, -EINVAL);
2032 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2033 assert_return(!bus_pid_changed(bus), -ECHILD);
2035 if (bus->state == BUS_CLOSED)
2038 if (bus->inotify_fd >= 0)
2039 return bus->inotify_fd;
2041 if (bus->input_fd >= 0)
2042 return bus->input_fd;
2047 _public_ int sd_bus_get_events(sd_bus *bus) {
2050 assert_return(bus, -EINVAL);
2051 assert_return(!bus_pid_changed(bus), -ECHILD);
2053 switch (bus->state) {
2059 case BUS_WATCH_BIND:
2067 case BUS_AUTHENTICATING:
2068 if (bus_socket_auth_needs_write(bus))
2076 if (bus->rqueue_size <= 0)
2078 if (bus->wqueue_size > 0)
2086 assert_not_reached("Unknown state");
2092 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2093 struct reply_callback *c;
2095 assert_return(bus, -EINVAL);
2096 assert_return(timeout_usec, -EINVAL);
2097 assert_return(!bus_pid_changed(bus), -ECHILD);
2099 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2102 if (bus->track_queue) {
2107 switch (bus->state) {
2109 case BUS_AUTHENTICATING:
2110 *timeout_usec = bus->auth_timeout;
2115 if (bus->rqueue_size > 0) {
2120 c = prioq_peek(bus->reply_callbacks_prioq);
2122 *timeout_usec = (uint64_t) -1;
2126 if (c->timeout_usec == 0) {
2127 *timeout_usec = (uint64_t) -1;
2131 *timeout_usec = c->timeout_usec;
2138 case BUS_WATCH_BIND:
2140 *timeout_usec = (uint64_t) -1;
2144 assert_not_reached("Unknown or unexpected stat");
2148 static int process_timeout(sd_bus *bus) {
2149 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2150 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2151 struct reply_callback *c;
2158 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2160 c = prioq_peek(bus->reply_callbacks_prioq);
2164 n = now(CLOCK_MONOTONIC);
2165 if (c->timeout_usec > n)
2168 r = bus_message_new_synthetic_error(
2171 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2176 r = bus_seal_synthetic_message(bus, m);
2180 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2181 c->timeout_usec = 0;
2183 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2186 slot = container_of(c, sd_bus_slot, reply_callback);
2188 bus->iteration_counter++;
2190 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2192 bus->current_message = m;
2193 bus->current_slot = sd_bus_slot_ref(slot);
2194 bus->current_handler = c->callback;
2195 bus->current_userdata = slot->userdata;
2196 r = c->callback(m, slot->userdata, &error_buffer);
2197 bus->current_userdata = NULL;
2198 bus->current_handler = NULL;
2199 bus->current_slot = NULL;
2200 bus->current_message = NULL;
2202 if (slot->floating) {
2203 bus_slot_disconnect(slot);
2204 sd_bus_slot_unref(slot);
2207 sd_bus_slot_unref(slot);
2209 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2210 * and ignore the callback handler's return value. */
2214 return bus_maybe_reply_error(m, r, &error_buffer);
2217 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2221 if (bus->state != BUS_HELLO)
2224 /* Let's make sure the first message on the bus is the HELLO
2225 * reply. But note that we don't actually parse the message
2226 * here (we leave that to the usual handling), we just verify
2227 * we don't let any earlier msg through. */
2229 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2232 if (m->reply_cookie != 1)
2238 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2239 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2240 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2241 struct reply_callback *c;
2249 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2252 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2255 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2261 slot = container_of(c, sd_bus_slot, reply_callback);
2263 if (m->n_fds > 0 && !bus->accept_fd) {
2265 /* If the reply contained a file descriptor which we
2266 * didn't want we pass an error instead. */
2268 r = bus_message_new_synthetic_error(
2271 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2276 /* Copy over original timestamp */
2277 synthetic_reply->realtime = m->realtime;
2278 synthetic_reply->monotonic = m->monotonic;
2279 synthetic_reply->seqnum = m->seqnum;
2281 r = bus_seal_synthetic_message(bus, synthetic_reply);
2285 m = synthetic_reply;
2287 r = sd_bus_message_rewind(m, true);
2292 if (c->timeout_usec != 0) {
2293 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2294 c->timeout_usec = 0;
2297 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2299 bus->current_slot = sd_bus_slot_ref(slot);
2300 bus->current_handler = c->callback;
2301 bus->current_userdata = slot->userdata;
2302 r = c->callback(m, slot->userdata, &error_buffer);
2303 bus->current_userdata = NULL;
2304 bus->current_handler = NULL;
2305 bus->current_slot = NULL;
2307 if (slot->floating) {
2308 bus_slot_disconnect(slot);
2309 sd_bus_slot_unref(slot);
2312 sd_bus_slot_unref(slot);
2314 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2315 * ignore the callback handler's return value. */
2319 return bus_maybe_reply_error(m, r, &error_buffer);
2322 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2323 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2324 struct filter_callback *l;
2331 bus->filter_callbacks_modified = false;
2333 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2336 if (bus->filter_callbacks_modified)
2339 /* Don't run this more than once per iteration */
2340 if (l->last_iteration == bus->iteration_counter)
2343 l->last_iteration = bus->iteration_counter;
2345 r = sd_bus_message_rewind(m, true);
2349 slot = container_of(l, sd_bus_slot, filter_callback);
2351 bus->current_slot = sd_bus_slot_ref(slot);
2352 bus->current_handler = l->callback;
2353 bus->current_userdata = slot->userdata;
2354 r = l->callback(m, slot->userdata, &error_buffer);
2355 bus->current_userdata = NULL;
2356 bus->current_handler = NULL;
2357 bus->current_slot = sd_bus_slot_unref(slot);
2359 r = bus_maybe_reply_error(m, r, &error_buffer);
2365 } while (bus->filter_callbacks_modified);
2370 static int process_match(sd_bus *bus, sd_bus_message *m) {
2377 bus->match_callbacks_modified = false;
2379 r = bus_match_run(bus, &bus->match_callbacks, m);
2383 } while (bus->match_callbacks_modified);
2388 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2389 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2395 if (bus->is_monitor)
2398 if (bus->manual_peer_interface)
2401 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2404 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2407 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2410 if (streq_ptr(m->member, "Ping"))
2411 r = sd_bus_message_new_method_return(m, &reply);
2412 else if (streq_ptr(m->member, "GetMachineId")) {
2416 r = sd_id128_get_machine(&id);
2420 r = sd_bus_message_new_method_return(m, &reply);
2424 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2426 r = sd_bus_message_new_method_errorf(
2428 SD_BUS_ERROR_UNKNOWN_METHOD,
2429 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2435 r = sd_bus_send(bus, reply, NULL);
2442 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2446 /* If we got a message with a file descriptor which we didn't
2447 * want to accept, then let's drop it. How can this even
2448 * happen? For example, when the kernel queues a message into
2449 * an activatable names's queue which allows fds, and then is
2450 * delivered to us later even though we ourselves did not
2453 if (bus->is_monitor)
2462 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2463 return 1; /* just eat it up */
2465 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2468 static int process_message(sd_bus *bus, sd_bus_message *m) {
2474 bus->current_message = m;
2475 bus->iteration_counter++;
2477 log_debug_bus_message(m);
2479 r = process_hello(bus, m);
2483 r = process_reply(bus, m);
2487 r = process_fd_check(bus, m);
2491 r = process_filter(bus, m);
2495 r = process_match(bus, m);
2499 r = process_builtin(bus, m);
2503 r = bus_process_object(bus, m);
2506 bus->current_message = NULL;
2510 static int dispatch_track(sd_bus *bus) {
2513 if (!bus->track_queue)
2516 bus_track_dispatch(bus->track_queue);
2520 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2521 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2525 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2527 r = process_timeout(bus);
2531 r = dispatch_wqueue(bus);
2535 r = dispatch_track(bus);
2539 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2545 r = process_message(bus, m);
2550 r = sd_bus_message_rewind(m, true);
2559 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2561 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2562 strna(sd_bus_message_get_sender(m)),
2563 strna(sd_bus_message_get_path(m)),
2564 strna(sd_bus_message_get_interface(m)),
2565 strna(sd_bus_message_get_member(m)));
2567 r = sd_bus_reply_method_errorf(
2569 SD_BUS_ERROR_UNKNOWN_OBJECT,
2570 "Unknown object '%s'.", m->path);
2584 static int bus_exit_now(sd_bus *bus) {
2587 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2588 * sd_event_exit(), otherwise invokes libc exit(). */
2590 if (bus->exited) /* did we already exit? */
2592 if (!bus->exit_triggered) /* was the exit condition triggered? */
2594 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2597 bus->exited = true; /* never exit more than once */
2599 log_debug("Bus connection disconnected, exiting.");
2602 return sd_event_exit(bus->event, EXIT_FAILURE);
2606 assert_not_reached("exit() didn't exit?");
2609 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2610 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2611 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2618 r = bus_message_new_synthetic_error(
2621 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2626 r = bus_seal_synthetic_message(bus, m);
2630 if (c->timeout_usec != 0) {
2631 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2632 c->timeout_usec = 0;
2635 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2638 slot = container_of(c, sd_bus_slot, reply_callback);
2640 bus->iteration_counter++;
2642 bus->current_message = m;
2643 bus->current_slot = sd_bus_slot_ref(slot);
2644 bus->current_handler = c->callback;
2645 bus->current_userdata = slot->userdata;
2646 r = c->callback(m, slot->userdata, &error_buffer);
2647 bus->current_userdata = NULL;
2648 bus->current_handler = NULL;
2649 bus->current_slot = NULL;
2650 bus->current_message = NULL;
2652 if (slot->floating) {
2653 bus_slot_disconnect(slot);
2654 sd_bus_slot_unref(slot);
2657 sd_bus_slot_unref(slot);
2659 return bus_maybe_reply_error(m, r, &error_buffer);
2662 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2663 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2664 struct reply_callback *c;
2668 assert(bus->state == BUS_CLOSING);
2670 /* First, fail all outstanding method calls */
2671 c = ordered_hashmap_first(bus->reply_callbacks);
2673 return process_closing_reply_callback(bus, c);
2675 /* Then, fake-drop all remaining bus tracking references */
2677 bus_track_close(bus->tracks);
2681 /* Then, synthesize a Disconnected message */
2682 r = sd_bus_message_new_signal(
2685 "/org/freedesktop/DBus/Local",
2686 "org.freedesktop.DBus.Local",
2691 bus_message_set_sender_local(bus, m);
2693 r = bus_seal_synthetic_message(bus, m);
2699 bus->current_message = m;
2700 bus->iteration_counter++;
2702 r = process_filter(bus, m);
2706 r = process_match(bus, m);
2710 /* Nothing else to do, exit now, if the condition holds */
2711 bus->exit_triggered = true;
2712 (void) bus_exit_now(bus);
2722 bus->current_message = NULL;
2727 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2728 BUS_DONT_DESTROY(bus);
2731 /* Returns 0 when we didn't do anything. This should cause the
2732 * caller to invoke sd_bus_wait() before returning the next
2733 * time. Returns > 0 when we did something, which possibly
2734 * means *ret is filled in with an unprocessed message. */
2736 assert_return(bus, -EINVAL);
2737 assert_return(!bus_pid_changed(bus), -ECHILD);
2739 /* We don't allow recursively invoking sd_bus_process(). */
2740 assert_return(!bus->current_message, -EBUSY);
2741 assert(!bus->current_slot);
2743 switch (bus->state) {
2751 case BUS_WATCH_BIND:
2752 r = bus_socket_process_watch_bind(bus);
2756 r = bus_socket_process_opening(bus);
2759 case BUS_AUTHENTICATING:
2760 r = bus_socket_process_authenticating(bus);
2765 r = process_running(bus, hint_priority, priority, ret);
2769 /* This branch initializes *ret, hence we don't use the generic error checking below */
2773 return process_closing(bus, ret);
2776 assert_not_reached("Unknown state");
2779 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2780 bus_enter_closing(bus);
2791 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2792 return bus_process_internal(bus, false, 0, ret);
2795 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2796 return bus_process_internal(bus, true, priority, ret);
2799 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2800 struct pollfd p[2] = {};
2803 usec_t m = USEC_INFINITY;
2807 if (bus->state == BUS_CLOSING)
2810 if (!BUS_IS_OPEN(bus->state))
2813 if (bus->state == BUS_WATCH_BIND) {
2814 assert(bus->inotify_fd >= 0);
2816 p[0].events = POLLIN;
2817 p[0].fd = bus->inotify_fd;
2822 e = sd_bus_get_events(bus);
2827 /* The caller really needs some more data, he doesn't
2828 * care about what's already read, or any timeouts
2829 * except its own. */
2833 /* The caller wants to process if there's something to
2834 * process, but doesn't care otherwise */
2836 r = sd_bus_get_timeout(bus, &until);
2840 m = usec_sub_unsigned(until, now(CLOCK_MONOTONIC));
2843 p[0].fd = bus->input_fd;
2844 if (bus->output_fd == bus->input_fd) {
2848 p[0].events = e & POLLIN;
2849 p[1].fd = bus->output_fd;
2850 p[1].events = e & POLLOUT;
2855 if (timeout_usec != (uint64_t) -1 && (m == USEC_INFINITY || timeout_usec < m))
2858 r = ppoll(p, n, m == USEC_INFINITY ? NULL : timespec_store(&ts, m), NULL);
2862 return r > 0 ? 1 : 0;
2865 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2867 assert_return(bus, -EINVAL);
2868 assert_return(!bus_pid_changed(bus), -ECHILD);
2870 if (bus->state == BUS_CLOSING)
2873 if (!BUS_IS_OPEN(bus->state))
2876 if (bus->rqueue_size > 0)
2879 return bus_poll(bus, false, timeout_usec);
2882 _public_ int sd_bus_flush(sd_bus *bus) {
2885 assert_return(bus, -EINVAL);
2886 assert_return(!bus_pid_changed(bus), -ECHILD);
2888 if (bus->state == BUS_CLOSING)
2891 if (!BUS_IS_OPEN(bus->state))
2894 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
2895 if (bus->state == BUS_WATCH_BIND)
2898 r = bus_ensure_running(bus);
2902 if (bus->wqueue_size <= 0)
2906 r = dispatch_wqueue(bus);
2908 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2909 bus_enter_closing(bus);
2916 if (bus->wqueue_size <= 0)
2919 r = bus_poll(bus, false, (uint64_t) -1);
2925 _public_ int sd_bus_add_filter(
2928 sd_bus_message_handler_t callback,
2933 assert_return(bus, -EINVAL);
2934 assert_return(callback, -EINVAL);
2935 assert_return(!bus_pid_changed(bus), -ECHILD);
2937 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2941 s->filter_callback.callback = callback;
2943 bus->filter_callbacks_modified = true;
2944 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2952 _public_ int sd_bus_add_match(
2956 sd_bus_message_handler_t callback,
2959 struct bus_match_component *components = NULL;
2960 unsigned n_components = 0;
2961 sd_bus_slot *s = NULL;
2964 assert_return(bus, -EINVAL);
2965 assert_return(match, -EINVAL);
2966 assert_return(!bus_pid_changed(bus), -ECHILD);
2968 r = bus_match_parse(match, &components, &n_components);
2972 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2978 s->match_callback.callback = callback;
2980 if (bus->bus_client) {
2981 enum bus_match_scope scope;
2983 scope = bus_match_get_scope(components, n_components);
2985 /* Do not install server-side matches for matches
2986 * against the local service, interface or bus path. */
2987 if (scope != BUS_MATCH_LOCAL) {
2989 /* We store the original match string, so that
2990 * we can use it to remove the match again. */
2992 s->match_callback.match_string = strdup(match);
2993 if (!s->match_callback.match_string) {
2998 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components);
3002 s->match_added = true;
3006 bus->match_callbacks_modified = true;
3007 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3016 bus_match_parse_free(components, n_components);
3017 sd_bus_slot_unref(s);
3022 #if 0 /// UNNEEDED by elogind
3023 int bus_remove_match_by_string(
3026 sd_bus_message_handler_t callback,
3029 struct bus_match_component *components = NULL;
3030 unsigned n_components = 0;
3031 struct match_callback *c;
3034 assert_return(bus, -EINVAL);
3035 assert_return(match, -EINVAL);
3036 assert_return(!bus_pid_changed(bus), -ECHILD);
3038 r = bus_match_parse(match, &components, &n_components);
3042 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3046 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3049 bus_match_parse_free(components, n_components);
3055 bool bus_pid_changed(sd_bus *bus) {
3058 /* We don't support people creating a bus connection and
3059 * keeping it around over a fork(). Let's complain. */
3061 return bus->original_pid != getpid_cached();
3064 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3065 sd_bus *bus = userdata;
3070 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3072 r = sd_bus_process(bus, NULL);
3074 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3075 bus_enter_closing(bus);
3081 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3082 sd_bus *bus = userdata;
3087 r = sd_bus_process(bus, NULL);
3089 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3090 bus_enter_closing(bus);
3096 static int prepare_callback(sd_event_source *s, void *userdata) {
3097 sd_bus *bus = userdata;
3104 e = sd_bus_get_events(bus);
3110 if (bus->output_fd != bus->input_fd) {
3112 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3116 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3118 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3122 r = sd_bus_get_timeout(bus, &until);
3128 j = sd_event_source_set_time(bus->time_event_source, until);
3135 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3142 log_debug_errno(r, "Preparing of bus events failed, closing down: %m");
3143 bus_enter_closing(bus);
3148 static int quit_callback(sd_event_source *event, void *userdata) {
3149 sd_bus *bus = userdata;
3159 int bus_attach_io_events(sd_bus *bus) {
3164 if (bus->input_fd < 0)
3170 if (!bus->input_io_event_source) {
3171 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3175 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3179 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3183 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3185 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3190 if (bus->output_fd != bus->input_fd) {
3191 assert(bus->output_fd >= 0);
3193 if (!bus->output_io_event_source) {
3194 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3198 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3202 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3204 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3213 static void bus_detach_io_events(sd_bus *bus) {
3216 if (bus->input_io_event_source) {
3217 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3218 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3221 if (bus->output_io_event_source) {
3222 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3223 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3227 int bus_attach_inotify_event(sd_bus *bus) {
3232 if (bus->inotify_fd < 0)
3238 if (!bus->inotify_event_source) {
3239 r = sd_event_add_io(bus->event, &bus->inotify_event_source, bus->inotify_fd, EPOLLIN, io_callback, bus);
3243 r = sd_event_source_set_priority(bus->inotify_event_source, bus->event_priority);
3247 r = sd_event_source_set_description(bus->inotify_event_source, "bus-inotify");
3249 r = sd_event_source_set_io_fd(bus->inotify_event_source, bus->inotify_fd);
3256 static void bus_detach_inotify_event(sd_bus *bus) {
3259 if (bus->inotify_event_source) {
3260 sd_event_source_set_enabled(bus->inotify_event_source, SD_EVENT_OFF);
3261 bus->inotify_event_source = sd_event_source_unref(bus->inotify_event_source);
3265 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3268 assert_return(bus, -EINVAL);
3269 assert_return(!bus->event, -EBUSY);
3271 assert(!bus->input_io_event_source);
3272 assert(!bus->output_io_event_source);
3273 assert(!bus->time_event_source);
3276 bus->event = sd_event_ref(event);
3278 r = sd_event_default(&bus->event);
3283 bus->event_priority = priority;
3285 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3289 r = sd_event_source_set_priority(bus->time_event_source, priority);
3293 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3297 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3301 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3305 r = bus_attach_io_events(bus);
3309 r = bus_attach_inotify_event(bus);
3316 sd_bus_detach_event(bus);
3320 _public_ int sd_bus_detach_event(sd_bus *bus) {
3321 assert_return(bus, -EINVAL);
3326 bus_detach_io_events(bus);
3327 bus_detach_inotify_event(bus);
3329 if (bus->time_event_source) {
3330 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3331 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3334 if (bus->quit_event_source) {
3335 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3336 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3339 bus->event = sd_event_unref(bus->event);
3343 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3344 assert_return(bus, NULL);
3349 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3350 assert_return(bus, NULL);
3352 return bus->current_message;
3355 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3356 assert_return(bus, NULL);
3358 return bus->current_slot;
3361 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3362 assert_return(bus, NULL);
3364 return bus->current_handler;
3367 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3368 assert_return(bus, NULL);
3370 return bus->current_userdata;
3373 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3378 assert(default_bus);
3381 return !!*default_bus;
3384 *ret = sd_bus_ref(*default_bus);
3392 b->default_bus_ptr = default_bus;
3400 _public_ int sd_bus_default_system(sd_bus **ret) {
3401 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3405 _public_ int sd_bus_default_user(sd_bus **ret) {
3406 #if 0 /// elogind does not support user buses
3407 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3409 return sd_bus_default_system(ret);
3413 _public_ int sd_bus_default(sd_bus **ret) {
3417 /* Let's try our best to reuse another cached connection. If
3418 * the starter bus type is set, connect via our normal
3419 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3420 * we can share the connection with the user/system default
3423 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3425 if (streq(e, "system"))
3426 return sd_bus_default_system(ret);
3427 #if 0 /// elogind does not support systemd units
3428 else if (STR_IN_SET(e, "user", "session"))
3429 return sd_bus_default_user(ret);
3433 /* No type is specified, so we have not other option than to
3434 * use the starter address if it is set. */
3435 e = secure_getenv("DBUS_STARTER_ADDRESS");
3437 return bus_default(sd_bus_open, &default_starter_bus, ret);
3439 /* Finally, if nothing is set use the cached connection for
3440 * the right scope */
3442 #if 0 /// elogind does not support systemd user instances
3443 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3444 return sd_bus_default_user(ret);
3447 return sd_bus_default_system(ret);
3450 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3451 assert_return(b, -EINVAL);
3452 assert_return(tid, -EINVAL);
3453 assert_return(!bus_pid_changed(b), -ECHILD);
3461 return sd_event_get_tid(b->event, tid);
3466 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3467 _cleanup_free_ char *e = NULL;
3470 assert_return(object_path_is_valid(prefix), -EINVAL);
3471 assert_return(external_id, -EINVAL);
3472 assert_return(ret_path, -EINVAL);
3474 e = bus_label_escape(external_id);
3478 ret = strjoin(prefix, "/", e);
3486 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3490 assert_return(object_path_is_valid(path), -EINVAL);
3491 assert_return(object_path_is_valid(prefix), -EINVAL);
3492 assert_return(external_id, -EINVAL);
3494 e = object_path_startswith(path, prefix);
3496 *external_id = NULL;
3500 ret = bus_label_unescape(e);
3508 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3509 _cleanup_strv_free_ char **labels = NULL;
3510 char *path, *path_pos, **label_pos;
3511 const char *sep, *template_pos;
3516 assert_return(out, -EINVAL);
3517 assert_return(path_template, -EINVAL);
3519 path_length = strlen(path_template);
3521 va_start(list, path_template);
3522 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3526 arg = va_arg(list, const char *);
3532 label = bus_label_escape(arg);
3538 r = strv_consume(&labels, label);
3544 /* add label length, but account for the format character */
3545 path_length += strlen(label) - 1;
3549 path = malloc(path_length + 1);
3556 for (template_pos = path_template; *template_pos; ) {
3557 sep = strchrnul(template_pos, '%');
3558 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3562 path_pos = stpcpy(path_pos, *label_pos++);
3563 template_pos = sep + 1;
3571 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3572 _cleanup_strv_free_ char **labels = NULL;
3573 const char *template_pos, *path_pos;
3579 * This decodes an object-path based on a template argument. The
3580 * template consists of a verbatim path, optionally including special
3583 * - Each occurrence of '%' in the template matches an arbitrary
3584 * substring of a label in the given path. At most one such
3585 * directive is allowed per label. For each such directive, the
3586 * caller must provide an output parameter (char **) via va_arg. If
3587 * NULL is passed, the given label is verified, but not returned.
3588 * For each matched label, the *decoded* label is stored in the
3589 * passed output argument, and the caller is responsible to free
3590 * it. Note that the output arguments are only modified if the
3591 * actualy path matched the template. Otherwise, they're left
3594 * This function returns <0 on error, 0 if the path does not match the
3595 * template, 1 if it matched.
3598 assert_return(path, -EINVAL);
3599 assert_return(path_template, -EINVAL);
3603 for (template_pos = path_template; *template_pos; ) {
3608 /* verify everything until the next '%' matches verbatim */
3609 sep = strchrnul(template_pos, '%');
3610 length = sep - template_pos;
3611 if (strncmp(path_pos, template_pos, length))
3615 template_pos += length;
3620 /* We found the next '%' character. Everything up until here
3621 * matched. We now skip ahead to the end of this label and make
3622 * sure it matches the tail of the label in the path. Then we
3623 * decode the string in-between and save it for later use. */
3625 ++template_pos; /* skip over '%' */
3627 sep = strchrnul(template_pos, '/');
3628 length = sep - template_pos; /* length of suffix to match verbatim */
3630 /* verify the suffixes match */
3631 sep = strchrnul(path_pos, '/');
3632 if (sep - path_pos < (ssize_t)length ||
3633 strncmp(sep - length, template_pos, length))
3636 template_pos += length; /* skip over matched label */
3637 length = sep - path_pos - length; /* length of sub-label to decode */
3639 /* store unescaped label for later use */
3640 label = bus_label_unescape_n(path_pos, length);
3644 r = strv_consume(&labels, label);
3648 path_pos = sep; /* skip decoded label and suffix */
3651 /* end of template must match end of path */
3655 /* copy the labels over to the caller */
3656 va_start(list, path_template);
3657 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3660 arg = va_arg(list, char **);
3668 labels = mfree(labels);
3672 _public_ int sd_bus_try_close(sd_bus *bus) {
3673 assert_return(bus, -EINVAL);
3674 assert_return(!bus_pid_changed(bus), -ECHILD);
3679 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3680 assert_return(bus, -EINVAL);
3681 assert_return(description, -EINVAL);
3682 assert_return(bus->description, -ENXIO);
3683 assert_return(!bus_pid_changed(bus), -ECHILD);
3685 *description = bus->description;
3689 int bus_get_root_path(sd_bus *bus) {
3692 if (bus->cgroup_root)
3695 r = cg_get_root_path(&bus->cgroup_root);
3697 bus->cgroup_root = strdup("/");
3698 if (!bus->cgroup_root)
3707 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3708 assert_return(bus, -EINVAL);
3709 assert_return(scope, -EINVAL);
3710 assert_return(!bus_pid_changed(bus), -ECHILD);
3717 if (bus->is_system) {
3725 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3727 assert_return(bus, -EINVAL);
3728 assert_return(address, -EINVAL);
3729 assert_return(!bus_pid_changed(bus), -ECHILD);
3732 *address = bus->address;
3739 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3740 assert_return(bus, -EINVAL);
3741 assert_return(mask, -EINVAL);
3742 assert_return(!bus_pid_changed(bus), -ECHILD);
3744 *mask = bus->creds_mask;
3748 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3749 assert_return(bus, -EINVAL);
3750 assert_return(!bus_pid_changed(bus), -ECHILD);
3752 return bus->bus_client;
3755 _public_ int sd_bus_is_server(sd_bus *bus) {
3756 assert_return(bus, -EINVAL);
3757 assert_return(!bus_pid_changed(bus), -ECHILD);
3759 return bus->is_server;
3762 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3763 assert_return(bus, -EINVAL);
3764 assert_return(!bus_pid_changed(bus), -ECHILD);
3766 return bus->anonymous_auth;
3769 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3770 assert_return(bus, -EINVAL);
3771 assert_return(!bus_pid_changed(bus), -ECHILD);
3773 return bus->trusted;
3776 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3777 assert_return(bus, -EINVAL);
3778 assert_return(!bus_pid_changed(bus), -ECHILD);
3780 return bus->is_monitor;
3783 static void flush_close(sd_bus *bus) {
3787 /* Flushes and closes the specified bus. We take a ref before,
3788 * to ensure the flushing does not cause the bus to be
3791 sd_bus_flush_close_unref(sd_bus_ref(bus));
3794 _public_ void sd_bus_default_flush_close(void) {
3795 flush_close(default_starter_bus);
3796 #if 0 /// elogind does not support user buses
3797 flush_close(default_user_bus);
3799 flush_close(default_system_bus);
3802 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
3803 assert_return(bus, -EINVAL);
3805 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
3806 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
3807 * from the client side. */
3808 bus->exit_on_disconnect = b;
3810 /* If the exit condition was triggered already, exit immediately. */
3811 return bus_exit_now(bus);
3814 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
3815 assert_return(bus, -EINVAL);
3817 return bus->exit_on_disconnect;