1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
35 #include "cgroup-util.h"
36 #include "hostname-util.h"
37 #include "bus-label.h"
40 #include "bus-internal.h"
41 #include "bus-message.h"
43 #include "bus-socket.h"
44 #include "bus-kernel.h"
45 #include "bus-control.h"
46 #include "bus-objects.h"
48 #include "bus-container.h"
49 #include "bus-protocol.h"
50 #include "bus-track.h"
53 #define log_debug_bus_message(m) \
55 sd_bus_message *_mm = (m); \
56 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
57 bus_message_type_to_string(_mm->header->type), \
58 strna(sd_bus_message_get_sender(_mm)), \
59 strna(sd_bus_message_get_destination(_mm)), \
60 strna(sd_bus_message_get_path(_mm)), \
61 strna(sd_bus_message_get_interface(_mm)), \
62 strna(sd_bus_message_get_member(_mm)), \
63 BUS_MESSAGE_COOKIE(_mm), \
65 strna(_mm->error.message)); \
68 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
69 static int attach_io_events(sd_bus *b);
70 static void detach_io_events(sd_bus *b);
72 static thread_local sd_bus *default_system_bus = NULL;
73 // UNNEEDED static thread_local sd_bus *default_user_bus = NULL;
74 static thread_local sd_bus *default_starter_bus = NULL;
76 static void bus_close_fds(sd_bus *b) {
81 if (b->input_fd != b->output_fd)
82 safe_close(b->output_fd);
83 b->output_fd = b->input_fd = safe_close(b->input_fd);
86 static void bus_reset_queues(sd_bus *b) {
89 while (b->rqueue_size > 0)
90 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
92 b->rqueue = mfree(b->rqueue);
93 b->rqueue_allocated = 0;
95 while (b->wqueue_size > 0)
96 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
98 b->wqueue = mfree(b->wqueue);
99 b->wqueue_allocated = 0;
102 static void bus_free(sd_bus *b) {
106 assert(!b->track_queue);
108 b->state = BUS_CLOSED;
110 sd_bus_detach_event(b);
112 while ((s = b->slots)) {
113 /* At this point only floating slots can still be
114 * around, because the non-floating ones keep a
115 * reference to the bus, and we thus couldn't be
116 * destructing right now... We forcibly disconnect the
117 * slots here, so that they still can be referenced by
118 * apps, but are dead. */
121 bus_slot_disconnect(s);
122 sd_bus_slot_unref(s);
125 if (b->default_bus_ptr)
126 *b->default_bus_ptr = NULL;
131 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
135 free(b->unique_name);
136 free(b->auth_buffer);
141 free(b->cgroup_root);
142 free(b->description);
145 strv_free(b->exec_argv);
147 close_many(b->fds, b->n_fds);
152 ordered_hashmap_free_free(b->reply_callbacks);
153 prioq_free(b->reply_callbacks_prioq);
155 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
156 bus_match_free(&b->match_callbacks);
158 hashmap_free_free(b->vtable_methods);
159 hashmap_free_free(b->vtable_properties);
161 assert(hashmap_isempty(b->nodes));
162 hashmap_free(b->nodes);
164 bus_kernel_flush_memfd(b);
166 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
171 _public_ int sd_bus_new(sd_bus **ret) {
174 assert_return(ret, -EINVAL);
180 r->n_ref = REFCNT_INIT;
181 r->input_fd = r->output_fd = -1;
182 r->message_version = 1;
183 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
184 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
185 r->attach_flags |= KDBUS_ATTACH_NAMES;
186 r->original_pid = getpid();
188 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
190 /* We guarantee that wqueue always has space for at least one
192 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
201 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
204 assert_return(bus, -EINVAL);
205 assert_return(bus->state == BUS_UNSET, -EPERM);
206 assert_return(address, -EINVAL);
207 assert_return(!bus_pid_changed(bus), -ECHILD);
219 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
220 assert_return(bus, -EINVAL);
221 assert_return(bus->state == BUS_UNSET, -EPERM);
222 assert_return(input_fd >= 0, -EBADF);
223 assert_return(output_fd >= 0, -EBADF);
224 assert_return(!bus_pid_changed(bus), -ECHILD);
226 bus->input_fd = input_fd;
227 bus->output_fd = output_fd;
231 /// UNNEEDED by elogind
233 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
236 assert_return(bus, -EINVAL);
237 assert_return(bus->state == BUS_UNSET, -EPERM);
238 assert_return(path, -EINVAL);
239 assert_return(!strv_isempty(argv), -EINVAL);
240 assert_return(!bus_pid_changed(bus), -ECHILD);
252 free(bus->exec_path);
253 strv_free(bus->exec_argv);
261 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
262 assert_return(bus, -EINVAL);
263 assert_return(bus->state == BUS_UNSET, -EPERM);
264 assert_return(!bus_pid_changed(bus), -ECHILD);
266 bus->bus_client = !!b;
270 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
271 assert_return(bus, -EINVAL);
272 assert_return(bus->state == BUS_UNSET, -EPERM);
273 assert_return(!bus_pid_changed(bus), -ECHILD);
275 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
279 _public_ int sd_bus_negotiate_fds(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 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
288 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
290 assert_return(bus, -EINVAL);
291 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
292 assert_return(!bus_pid_changed(bus), -ECHILD);
294 new_flags = bus->attach_flags;
295 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
297 if (bus->attach_flags == new_flags)
300 bus->attach_flags = new_flags;
301 if (bus->state != BUS_UNSET && bus->is_kernel)
302 bus_kernel_realize_attach_flags(bus);
307 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
310 assert_return(bus, -EINVAL);
311 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
312 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
313 assert_return(!bus_pid_changed(bus), -ECHILD);
316 bus->creds_mask |= mask;
318 bus->creds_mask &= ~mask;
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);
373 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
374 assert_return(bus, -EINVAL);
375 assert_return(!bus_pid_changed(bus), -ECHILD);
377 bus->allow_interactive_authorization = !!b;
381 /// UNNEEDED by elogind
383 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
384 assert_return(bus, -EINVAL);
385 assert_return(!bus_pid_changed(bus), -ECHILD);
387 return bus->allow_interactive_authorization;
391 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
399 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
401 r = sd_bus_message_get_errno(reply);
405 r = sd_bus_message_read(reply, "s", &s);
409 if (!service_name_is_valid(s) || s[0] != ':')
412 bus->unique_name = strdup(s);
413 if (!bus->unique_name)
416 if (bus->state == BUS_HELLO)
417 bus->state = BUS_RUNNING;
422 static int bus_send_hello(sd_bus *bus) {
423 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
428 if (!bus->bus_client || bus->is_kernel)
431 r = sd_bus_message_new_method_call(
434 "org.freedesktop.DBus",
435 "/org/freedesktop/DBus",
436 "org.freedesktop.DBus",
441 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
444 int bus_start_running(sd_bus *bus) {
447 if (bus->bus_client && !bus->is_kernel) {
448 bus->state = BUS_HELLO;
452 bus->state = BUS_RUNNING;
456 static int parse_address_key(const char **p, const char *key, char **value) {
457 size_t l, n = 0, allocated = 0;
467 if (strncmp(*p, key, l) != 0)
480 while (*a != ';' && *a != ',' && *a != 0) {
498 c = (char) ((x << 4) | y);
505 if (!GREEDY_REALLOC(r, allocated, n + 2))
529 static void skip_address_key(const char **p) {
533 *p += strcspn(*p, ",");
539 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
540 _cleanup_free_ char *path = NULL, *abstract = NULL;
549 while (**p != 0 && **p != ';') {
550 r = parse_address_key(p, "guid", guid);
556 r = parse_address_key(p, "path", &path);
562 r = parse_address_key(p, "abstract", &abstract);
571 if (!path && !abstract)
574 if (path && abstract)
579 if (l > sizeof(b->sockaddr.un.sun_path))
582 b->sockaddr.un.sun_family = AF_UNIX;
583 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
584 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
585 } else if (abstract) {
586 l = strlen(abstract);
587 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
590 b->sockaddr.un.sun_family = AF_UNIX;
591 b->sockaddr.un.sun_path[0] = 0;
592 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
593 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
599 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
600 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
602 struct addrinfo *result, hints = {
603 .ai_socktype = SOCK_STREAM,
604 .ai_flags = AI_ADDRCONFIG,
612 while (**p != 0 && **p != ';') {
613 r = parse_address_key(p, "guid", guid);
619 r = parse_address_key(p, "host", &host);
625 r = parse_address_key(p, "port", &port);
631 r = parse_address_key(p, "family", &family);
644 if (streq(family, "ipv4"))
645 hints.ai_family = AF_INET;
646 else if (streq(family, "ipv6"))
647 hints.ai_family = AF_INET6;
652 r = getaddrinfo(host, port, &hints, &result);
656 return -EADDRNOTAVAIL;
658 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
659 b->sockaddr_size = result->ai_addrlen;
661 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 (**p != 0 && **p != ';') {
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);
748 for (j = 0; j < n_argv; j++)
756 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
757 _cleanup_free_ char *path = NULL;
765 while (**p != 0 && **p != ';') {
766 r = parse_address_key(p, "guid", guid);
772 r = parse_address_key(p, "path", &path);
791 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
792 _cleanup_free_ char *machine = NULL, *pid = NULL;
800 while (**p != 0 && **p != ';') {
801 r = parse_address_key(p, "guid", guid);
807 r = parse_address_key(p, "machine", &machine);
813 r = parse_address_key(p, "pid", &pid);
822 if (!machine == !pid)
826 if (!machine_name_is_valid(machine))
830 b->machine = machine;
833 b->machine = mfree(b->machine);
837 r = parse_pid(pid, &b->nspid);
843 b->sockaddr.un.sun_family = AF_UNIX;
844 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
845 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
850 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
851 _cleanup_free_ char *machine = NULL, *pid = NULL;
859 while (**p != 0 && **p != ';') {
860 r = parse_address_key(p, "guid", guid);
866 r = parse_address_key(p, "machine", &machine);
872 r = parse_address_key(p, "pid", &pid);
881 if (!machine == !pid)
885 if (!machine_name_is_valid(machine))
889 b->machine = machine;
892 b->machine = mfree(b->machine);
896 r = parse_pid(pid, &b->nspid);
902 r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
909 static void bus_reset_parsed_address(sd_bus *b) {
913 b->sockaddr_size = 0;
914 b->exec_argv = strv_free(b->exec_argv);
915 b->exec_path = mfree(b->exec_path);
916 b->server_id = SD_ID128_NULL;
917 b->kernel = mfree(b->kernel);
918 b->machine = mfree(b->machine);
922 static int bus_parse_next_address(sd_bus *b) {
923 _cleanup_free_ char *guid = NULL;
931 if (b->address[b->address_index] == 0)
934 bus_reset_parsed_address(b);
936 a = b->address + b->address_index;
945 if (startswith(a, "unix:")) {
948 r = parse_unix_address(b, &a, &guid);
953 } else if (startswith(a, "tcp:")) {
956 r = parse_tcp_address(b, &a, &guid);
962 } else if (startswith(a, "unixexec:")) {
965 r = parse_exec_address(b, &a, &guid);
971 } else if (startswith(a, "kernel:")) {
974 r = parse_kernel_address(b, &a, &guid);
979 } else if (startswith(a, "x-machine-unix:")) {
982 r = parse_container_unix_address(b, &a, &guid);
987 } else if (startswith(a, "x-machine-kernel:")) {
990 r = parse_container_kernel_address(b, &a, &guid);
1003 r = sd_id128_from_string(guid, &b->server_id);
1008 b->address_index = a - b->address;
1012 static int bus_start_address(sd_bus *b) {
1013 bool container_kdbus_available = false;
1014 bool kdbus_available = false;
1020 bool skipped = false;
1025 * Usually, if you provide multiple different bus-addresses, we
1026 * try all of them in order. We use the first one that
1027 * succeeds. However, if you mix kernel and unix addresses, we
1028 * never try unix-addresses if a previous kernel address was
1029 * tried and kdbus was available. This is required to prevent
1030 * clients to fallback to the bus-proxy if kdbus is available
1031 * but failed (eg., too many connections).
1035 r = bus_socket_exec(b);
1036 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1037 r = bus_container_connect_kernel(b);
1038 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1039 container_kdbus_available = true;
1041 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1042 if (!container_kdbus_available)
1043 r = bus_container_connect_socket(b);
1047 } else if (b->kernel) {
1048 r = bus_kernel_connect(b);
1049 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1050 kdbus_available = true;
1052 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1053 if (!kdbus_available)
1054 r = bus_socket_connect(b);
1062 r = attach_io_events(b);
1067 b->last_connect_error = -r;
1070 r = bus_parse_next_address(b);
1074 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1078 int bus_next_address(sd_bus *b) {
1081 bus_reset_parsed_address(b);
1082 return bus_start_address(b);
1085 static int bus_start_fd(sd_bus *b) {
1090 assert(b->input_fd >= 0);
1091 assert(b->output_fd >= 0);
1093 r = fd_nonblock(b->input_fd, true);
1097 r = fd_cloexec(b->input_fd, true);
1101 if (b->input_fd != b->output_fd) {
1102 r = fd_nonblock(b->output_fd, true);
1106 r = fd_cloexec(b->output_fd, true);
1111 if (fstat(b->input_fd, &st) < 0)
1114 if (S_ISCHR(b->input_fd))
1115 return bus_kernel_take_fd(b);
1117 return bus_socket_take_fd(b);
1120 _public_ int sd_bus_start(sd_bus *bus) {
1123 assert_return(bus, -EINVAL);
1124 assert_return(bus->state == BUS_UNSET, -EPERM);
1125 assert_return(!bus_pid_changed(bus), -ECHILD);
1127 bus->state = BUS_OPENING;
1129 if (bus->is_server && bus->bus_client)
1132 if (bus->input_fd >= 0)
1133 r = bus_start_fd(bus);
1134 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1135 r = bus_start_address(bus);
1144 return bus_send_hello(bus);
1147 _public_ int sd_bus_open(sd_bus **ret) {
1152 assert_return(ret, -EINVAL);
1154 /* Let's connect to the starter bus if it is set, and
1155 * otherwise to the bus that is appropropriate for the scope
1156 * we are running in */
1158 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1160 if (streq(e, "system"))
1161 return sd_bus_open_system(ret);
1162 /// elogind does not support systemd units
1164 else if (STR_IN_SET(e, "session", "user"))
1165 return sd_bus_open_user(ret);
1169 e = secure_getenv("DBUS_STARTER_ADDRESS");
1171 /// elogind does not support systemd units
1173 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1174 return sd_bus_open_user(ret);
1177 return sd_bus_open_system(ret);
1184 r = sd_bus_set_address(b, e);
1188 b->bus_client = true;
1190 /* We don't know whether the bus is trusted or not, so better
1191 * be safe, and authenticate everything */
1193 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1194 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1196 r = sd_bus_start(b);
1208 int bus_set_address_system(sd_bus *b) {
1212 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1214 return sd_bus_set_address(b, e);
1216 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1219 _public_ int sd_bus_open_system(sd_bus **ret) {
1223 assert_return(ret, -EINVAL);
1229 r = bus_set_address_system(b);
1233 b->bus_client = true;
1234 b->is_system = true;
1236 /* Let's do per-method access control on the system bus. We
1237 * need the caller's UID and capability set for that. */
1239 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1240 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1242 r = sd_bus_start(b);
1254 /// elogind can not open/use a user bus
1256 int bus_set_address_user(sd_bus *b) {
1263 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1265 return sd_bus_set_address(b, e);
1267 r = cg_pid_get_owner_uid(0, &uid);
1271 e = secure_getenv("XDG_RUNTIME_DIR");
1273 _cleanup_free_ char *ee = NULL;
1275 ee = bus_address_escape(e);
1279 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1281 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1290 _public_ int sd_bus_open_user(sd_bus **ret) {
1291 /// elogind does not support user buses
1296 assert_return(ret, -EINVAL);
1302 r = bus_set_address_user(b);
1306 b->bus_client = true;
1309 /* We don't do any per-method access control on the user
1313 r = sd_bus_start(b);
1324 return sd_bus_open_system(ret);
1328 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1329 _cleanup_free_ char *e = NULL;
1330 char *m = NULL, *c = NULL;
1335 /* Let's see if we shall enter some container */
1336 m = strchr(host, ':');
1340 /* Let's make sure this is not a port of some kind,
1341 * and is a valid machine name. */
1342 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1345 /* Cut out the host part */
1346 t = strndupa(host, m - host - 1);
1347 e = bus_address_escape(t);
1351 c = strjoina(",argv4=--machine=", m);
1356 e = bus_address_escape(host);
1361 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1368 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1372 assert_return(host, -EINVAL);
1373 assert_return(ret, -EINVAL);
1375 r = sd_bus_new(&bus);
1379 r = bus_set_address_system_remote(bus, host);
1383 bus->bus_client = true;
1384 bus->trusted = false;
1385 bus->is_system = true;
1387 r = sd_bus_start(bus);
1399 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1400 _cleanup_free_ char *e = NULL;
1405 e = bus_address_escape(machine);
1409 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1416 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1420 assert_return(machine, -EINVAL);
1421 assert_return(ret, -EINVAL);
1422 assert_return(machine_name_is_valid(machine), -EINVAL);
1424 r = sd_bus_new(&bus);
1428 r = bus_set_address_system_machine(bus, machine);
1432 bus->bus_client = true;
1433 bus->trusted = false;
1434 bus->is_system = true;
1436 r = sd_bus_start(bus);
1448 _public_ void sd_bus_close(sd_bus *bus) {
1452 if (bus->state == BUS_CLOSED)
1454 if (bus_pid_changed(bus))
1457 bus->state = BUS_CLOSED;
1459 sd_bus_detach_event(bus);
1461 /* Drop all queued messages so that they drop references to
1462 * the bus object and the bus may be freed */
1463 bus_reset_queues(bus);
1465 if (!bus->is_kernel)
1468 /* We'll leave the fd open in case this is a kernel bus, since
1469 * there might still be memblocks around that reference this
1470 * bus, and they might need to invoke the KDBUS_CMD_FREE
1471 * ioctl on the fd when they are freed. */
1474 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1482 return sd_bus_unref(bus);
1485 static void bus_enter_closing(sd_bus *bus) {
1488 if (bus->state != BUS_OPENING &&
1489 bus->state != BUS_AUTHENTICATING &&
1490 bus->state != BUS_HELLO &&
1491 bus->state != BUS_RUNNING)
1494 bus->state = BUS_CLOSING;
1497 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1498 assert_return(bus, NULL);
1500 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1505 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1511 i = REFCNT_DEC(bus->n_ref);
1519 /// UNNEEDED by elogind
1521 _public_ int sd_bus_is_open(sd_bus *bus) {
1523 assert_return(bus, -EINVAL);
1524 assert_return(!bus_pid_changed(bus), -ECHILD);
1526 return BUS_IS_OPEN(bus->state);
1530 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1533 assert_return(bus, -EINVAL);
1534 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1535 assert_return(!bus_pid_changed(bus), -ECHILD);
1537 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1540 if (type == SD_BUS_TYPE_UNIX_FD) {
1541 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1544 r = bus_ensure_running(bus);
1548 return bus->can_fds;
1551 return bus_type_is_valid(type);
1554 /// UNNEEDED by elogind
1556 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1559 assert_return(bus, -EINVAL);
1560 assert_return(id, -EINVAL);
1561 assert_return(!bus_pid_changed(bus), -ECHILD);
1563 r = bus_ensure_running(bus);
1567 *id = bus->server_id;
1572 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1577 /* If we copy the same message to multiple
1578 * destinations, avoid using the same cookie
1580 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1585 timeout = BUS_DEFAULT_TIMEOUT;
1587 return bus_message_seal(m, ++b->cookie, timeout);
1590 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1591 bool remarshal = false;
1595 /* wrong packet version */
1596 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1599 /* wrong packet endianness */
1600 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1603 /* TODO: kdbus-messages received from the kernel contain data which is
1604 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1605 * force remarshaling of the message. Technically, we could just
1606 * recreate the kdbus message, but that is non-trivial as other parts of
1607 * the message refer to m->kdbus already. This should be fixed! */
1608 if ((*m)->kdbus && (*m)->release_kdbus)
1611 return remarshal ? bus_message_remarshal(b, m) : 0;
1614 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1618 /* Fake some timestamps, if they were requested, and not
1619 * already initialized */
1620 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1621 if (m->realtime <= 0)
1622 m->realtime = now(CLOCK_REALTIME);
1624 if (m->monotonic <= 0)
1625 m->monotonic = now(CLOCK_MONOTONIC);
1628 /* The bus specification says the serial number cannot be 0,
1629 * hence let's fill something in for synthetic messages. Since
1630 * synthetic messages might have a fake sender and we don't
1631 * want to interfere with the real sender's serial numbers we
1632 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1633 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1634 * even though kdbus can do 64bit. */
1635 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1638 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1645 r = bus_kernel_write_message(bus, m, hint_sync_call);
1647 r = bus_socket_write_message(bus, m, idx);
1652 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1653 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1654 bus_message_type_to_string(m->header->type),
1655 strna(sd_bus_message_get_sender(m)),
1656 strna(sd_bus_message_get_destination(m)),
1657 strna(sd_bus_message_get_path(m)),
1658 strna(sd_bus_message_get_interface(m)),
1659 strna(sd_bus_message_get_member(m)),
1660 BUS_MESSAGE_COOKIE(m),
1662 strna(m->error.message));
1667 static int dispatch_wqueue(sd_bus *bus) {
1671 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1673 while (bus->wqueue_size > 0) {
1675 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1679 /* Didn't do anything this time */
1681 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1682 /* Fully written. Let's drop the entry from
1685 * This isn't particularly optimized, but
1686 * well, this is supposed to be our worst-case
1687 * buffer only, and the socket buffer is
1688 * supposed to be our primary buffer, and if
1689 * it got full, then all bets are off
1692 bus->wqueue_size --;
1693 sd_bus_message_unref(bus->wqueue[0]);
1694 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1704 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1708 return bus_kernel_read_message(bus, hint_priority, priority);
1710 return bus_socket_read_message(bus);
1713 int bus_rqueue_make_room(sd_bus *bus) {
1716 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1719 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1725 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1730 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1732 /* Note that the priority logic is only available on kdbus,
1733 * where the rqueue is unused. We check the rqueue here
1734 * anyway, because it's simple... */
1737 if (bus->rqueue_size > 0) {
1738 /* Dispatch a queued message */
1740 *m = bus->rqueue[0];
1741 bus->rqueue_size --;
1742 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1746 /* Try to read a new message */
1747 r = bus_read_message(bus, hint_priority, priority);
1757 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1758 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1761 assert_return(m, -EINVAL);
1766 assert_return(!bus_pid_changed(bus), -ECHILD);
1767 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1769 if (!BUS_IS_OPEN(bus->state))
1773 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1780 /* If the cookie number isn't kept, then we know that no reply
1782 if (!cookie && !m->sealed)
1783 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1785 r = bus_seal_message(bus, m, 0);
1789 /* Remarshall if we have to. This will possibly unref the
1790 * message and place a replacement in m */
1791 r = bus_remarshal_message(bus, &m);
1795 /* If this is a reply and no reply was requested, then let's
1796 * suppress this, if we can */
1800 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1803 r = bus_write_message(bus, m, hint_sync_call, &idx);
1805 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1806 bus_enter_closing(bus);
1813 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1814 /* Wasn't fully written. So let's remember how
1815 * much was written. Note that the first entry
1816 * of the wqueue array is always allocated so
1817 * that we always can remember how much was
1819 bus->wqueue[0] = sd_bus_message_ref(m);
1820 bus->wqueue_size = 1;
1825 /* Just append it to the queue. */
1827 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1830 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1833 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1838 *cookie = BUS_MESSAGE_COOKIE(m);
1843 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1844 return bus_send_internal(bus, m, cookie, false);
1847 /// UNNEEDED by elogind
1849 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1852 assert_return(m, -EINVAL);
1857 assert_return(!bus_pid_changed(bus), -ECHILD);
1859 if (!BUS_IS_OPEN(bus->state))
1862 if (!streq_ptr(m->destination, destination)) {
1867 r = sd_bus_message_set_destination(m, destination);
1872 return sd_bus_send(bus, m, cookie);
1876 static usec_t calc_elapse(uint64_t usec) {
1877 if (usec == (uint64_t) -1)
1880 return now(CLOCK_MONOTONIC) + usec;
1883 static int timeout_compare(const void *a, const void *b) {
1884 const struct reply_callback *x = a, *y = b;
1886 if (x->timeout != 0 && y->timeout == 0)
1889 if (x->timeout == 0 && y->timeout != 0)
1892 if (x->timeout < y->timeout)
1895 if (x->timeout > y->timeout)
1901 _public_ int sd_bus_call_async(
1905 sd_bus_message_handler_t callback,
1909 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1910 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1913 assert_return(m, -EINVAL);
1914 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1915 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1916 assert_return(callback, -EINVAL);
1921 assert_return(!bus_pid_changed(bus), -ECHILD);
1922 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1924 if (!BUS_IS_OPEN(bus->state))
1927 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1931 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1935 r = bus_seal_message(bus, m, usec);
1939 r = bus_remarshal_message(bus, &m);
1943 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1947 s->reply_callback.callback = callback;
1949 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1950 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1952 s->reply_callback.cookie = 0;
1956 s->reply_callback.timeout = calc_elapse(m->timeout);
1957 if (s->reply_callback.timeout != 0) {
1958 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1960 s->reply_callback.timeout = 0;
1965 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1976 int bus_ensure_running(sd_bus *bus) {
1981 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1983 if (bus->state == BUS_RUNNING)
1987 r = sd_bus_process(bus, NULL);
1990 if (bus->state == BUS_RUNNING)
1995 r = sd_bus_wait(bus, (uint64_t) -1);
2001 _public_ int sd_bus_call(
2005 sd_bus_error *error,
2006 sd_bus_message **reply) {
2008 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2014 bus_assert_return(m, -EINVAL, error);
2015 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2016 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2017 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2022 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2023 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2025 if (!BUS_IS_OPEN(bus->state)) {
2030 r = bus_ensure_running(bus);
2034 i = bus->rqueue_size;
2036 r = bus_seal_message(bus, m, usec);
2040 r = bus_remarshal_message(bus, &m);
2044 r = bus_send_internal(bus, m, &cookie, true);
2048 timeout = calc_elapse(m->timeout);
2053 while (i < bus->rqueue_size) {
2054 sd_bus_message *incoming = NULL;
2056 incoming = bus->rqueue[i];
2058 if (incoming->reply_cookie == cookie) {
2059 /* Found a match! */
2061 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2063 log_debug_bus_message(incoming);
2065 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2067 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2071 sd_bus_message_unref(incoming);
2076 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2077 sd_bus_message_unref(incoming);
2080 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2081 r = sd_bus_error_copy(error, &incoming->error);
2082 sd_bus_message_unref(incoming);
2089 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2092 streq(bus->unique_name, incoming->sender)) {
2094 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2097 /* Our own message? Somebody is trying
2098 * to send its own client a message,
2099 * let's not dead-lock, let's fail
2102 sd_bus_message_unref(incoming);
2107 /* Try to read more, right-away */
2111 r = bus_read_message(bus, false, 0);
2113 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2114 bus_enter_closing(bus);
2126 n = now(CLOCK_MONOTONIC);
2134 left = (uint64_t) -1;
2136 r = bus_poll(bus, true, left);
2144 r = dispatch_wqueue(bus);
2146 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2147 bus_enter_closing(bus);
2156 return sd_bus_error_set_errno(error, r);
2159 /// UNNEEDED by elogind
2161 _public_ int sd_bus_get_fd(sd_bus *bus) {
2163 assert_return(bus, -EINVAL);
2164 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2165 assert_return(!bus_pid_changed(bus), -ECHILD);
2167 return bus->input_fd;
2171 _public_ int sd_bus_get_events(sd_bus *bus) {
2174 assert_return(bus, -EINVAL);
2175 assert_return(!bus_pid_changed(bus), -ECHILD);
2177 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2180 if (bus->state == BUS_OPENING)
2182 else if (bus->state == BUS_AUTHENTICATING) {
2184 if (bus_socket_auth_needs_write(bus))
2189 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2190 if (bus->rqueue_size <= 0)
2192 if (bus->wqueue_size > 0)
2199 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2200 struct reply_callback *c;
2202 assert_return(bus, -EINVAL);
2203 assert_return(timeout_usec, -EINVAL);
2204 assert_return(!bus_pid_changed(bus), -ECHILD);
2206 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2209 if (bus->track_queue) {
2214 if (bus->state == BUS_CLOSING) {
2219 if (bus->state == BUS_AUTHENTICATING) {
2220 *timeout_usec = bus->auth_timeout;
2224 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2225 *timeout_usec = (uint64_t) -1;
2229 if (bus->rqueue_size > 0) {
2234 c = prioq_peek(bus->reply_callbacks_prioq);
2236 *timeout_usec = (uint64_t) -1;
2240 if (c->timeout == 0) {
2241 *timeout_usec = (uint64_t) -1;
2245 *timeout_usec = c->timeout;
2249 static int process_timeout(sd_bus *bus) {
2250 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2251 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2252 struct reply_callback *c;
2259 c = prioq_peek(bus->reply_callbacks_prioq);
2263 n = now(CLOCK_MONOTONIC);
2267 r = bus_message_new_synthetic_error(
2270 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2275 r = bus_seal_synthetic_message(bus, m);
2279 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2282 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2285 slot = container_of(c, sd_bus_slot, reply_callback);
2287 bus->iteration_counter ++;
2289 bus->current_message = m;
2290 bus->current_slot = sd_bus_slot_ref(slot);
2291 bus->current_handler = c->callback;
2292 bus->current_userdata = slot->userdata;
2293 r = c->callback(m, slot->userdata, &error_buffer);
2294 bus->current_userdata = NULL;
2295 bus->current_handler = NULL;
2296 bus->current_slot = NULL;
2297 bus->current_message = NULL;
2299 if (slot->floating) {
2300 bus_slot_disconnect(slot);
2301 sd_bus_slot_unref(slot);
2304 sd_bus_slot_unref(slot);
2306 return bus_maybe_reply_error(m, r, &error_buffer);
2309 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2313 if (bus->state != BUS_HELLO)
2316 /* Let's make sure the first message on the bus is the HELLO
2317 * reply. But note that we don't actually parse the message
2318 * here (we leave that to the usual handling), we just verify
2319 * we don't let any earlier msg through. */
2321 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2322 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2325 if (m->reply_cookie != 1)
2331 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2332 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2333 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2334 struct reply_callback *c;
2341 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2342 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2345 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2348 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2351 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2357 slot = container_of(c, sd_bus_slot, reply_callback);
2359 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2361 /* If the reply contained a file descriptor which we
2362 * didn't want we pass an error instead. */
2364 r = bus_message_new_synthetic_error(
2367 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2372 /* Copy over original timestamp */
2373 synthetic_reply->realtime = m->realtime;
2374 synthetic_reply->monotonic = m->monotonic;
2375 synthetic_reply->seqnum = m->seqnum;
2377 r = bus_seal_synthetic_message(bus, synthetic_reply);
2381 m = synthetic_reply;
2383 r = sd_bus_message_rewind(m, true);
2388 if (c->timeout != 0) {
2389 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2393 bus->current_slot = sd_bus_slot_ref(slot);
2394 bus->current_handler = c->callback;
2395 bus->current_userdata = slot->userdata;
2396 r = c->callback(m, slot->userdata, &error_buffer);
2397 bus->current_userdata = NULL;
2398 bus->current_handler = NULL;
2399 bus->current_slot = NULL;
2401 if (slot->floating) {
2402 bus_slot_disconnect(slot);
2403 sd_bus_slot_unref(slot);
2406 sd_bus_slot_unref(slot);
2408 return bus_maybe_reply_error(m, r, &error_buffer);
2411 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2412 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2413 struct filter_callback *l;
2420 bus->filter_callbacks_modified = false;
2422 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2425 if (bus->filter_callbacks_modified)
2428 /* Don't run this more than once per iteration */
2429 if (l->last_iteration == bus->iteration_counter)
2432 l->last_iteration = bus->iteration_counter;
2434 r = sd_bus_message_rewind(m, true);
2438 slot = container_of(l, sd_bus_slot, filter_callback);
2440 bus->current_slot = sd_bus_slot_ref(slot);
2441 bus->current_handler = l->callback;
2442 bus->current_userdata = slot->userdata;
2443 r = l->callback(m, slot->userdata, &error_buffer);
2444 bus->current_userdata = NULL;
2445 bus->current_handler = NULL;
2446 bus->current_slot = sd_bus_slot_unref(slot);
2448 r = bus_maybe_reply_error(m, r, &error_buffer);
2454 } while (bus->filter_callbacks_modified);
2459 static int process_match(sd_bus *bus, sd_bus_message *m) {
2466 bus->match_callbacks_modified = false;
2468 r = bus_match_run(bus, &bus->match_callbacks, m);
2472 } while (bus->match_callbacks_modified);
2477 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2478 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2484 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2487 if (bus->manual_peer_interface)
2490 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2493 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2496 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2499 if (streq_ptr(m->member, "Ping"))
2500 r = sd_bus_message_new_method_return(m, &reply);
2501 else if (streq_ptr(m->member, "GetMachineId")) {
2505 r = sd_id128_get_machine(&id);
2509 r = sd_bus_message_new_method_return(m, &reply);
2513 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2515 r = sd_bus_message_new_method_errorf(
2517 SD_BUS_ERROR_UNKNOWN_METHOD,
2518 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2524 r = sd_bus_send(bus, reply, NULL);
2531 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2535 /* If we got a message with a file descriptor which we didn't
2536 * want to accept, then let's drop it. How can this even
2537 * happen? For example, when the kernel queues a message into
2538 * an activatable names's queue which allows fds, and then is
2539 * delivered to us later even though we ourselves did not
2542 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2548 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2551 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2552 return 1; /* just eat it up */
2554 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2557 static int process_message(sd_bus *bus, sd_bus_message *m) {
2563 bus->current_message = m;
2564 bus->iteration_counter++;
2566 log_debug_bus_message(m);
2568 r = process_hello(bus, m);
2572 r = process_reply(bus, m);
2576 r = process_fd_check(bus, m);
2580 r = process_filter(bus, m);
2584 r = process_match(bus, m);
2588 r = process_builtin(bus, m);
2592 r = bus_process_object(bus, m);
2595 bus->current_message = NULL;
2599 static int dispatch_track(sd_bus *bus) {
2602 if (!bus->track_queue)
2605 bus_track_dispatch(bus->track_queue);
2609 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2610 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2614 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2616 r = process_timeout(bus);
2620 r = dispatch_wqueue(bus);
2624 r = dispatch_track(bus);
2628 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2634 r = process_message(bus, m);
2639 r = sd_bus_message_rewind(m, true);
2648 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2650 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2651 strna(sd_bus_message_get_sender(m)),
2652 strna(sd_bus_message_get_path(m)),
2653 strna(sd_bus_message_get_interface(m)),
2654 strna(sd_bus_message_get_member(m)));
2656 r = sd_bus_reply_method_errorf(
2658 SD_BUS_ERROR_UNKNOWN_OBJECT,
2659 "Unknown object '%s'.", m->path);
2673 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2674 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2675 struct reply_callback *c;
2679 assert(bus->state == BUS_CLOSING);
2681 c = ordered_hashmap_first(bus->reply_callbacks);
2683 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2686 /* First, fail all outstanding method calls */
2687 r = bus_message_new_synthetic_error(
2690 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2695 r = bus_seal_synthetic_message(bus, m);
2699 if (c->timeout != 0) {
2700 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2704 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2707 slot = container_of(c, sd_bus_slot, reply_callback);
2709 bus->iteration_counter++;
2711 bus->current_message = m;
2712 bus->current_slot = sd_bus_slot_ref(slot);
2713 bus->current_handler = c->callback;
2714 bus->current_userdata = slot->userdata;
2715 r = c->callback(m, slot->userdata, &error_buffer);
2716 bus->current_userdata = NULL;
2717 bus->current_handler = NULL;
2718 bus->current_slot = NULL;
2719 bus->current_message = NULL;
2721 if (slot->floating) {
2722 bus_slot_disconnect(slot);
2723 sd_bus_slot_unref(slot);
2726 sd_bus_slot_unref(slot);
2728 return bus_maybe_reply_error(m, r, &error_buffer);
2731 /* Then, synthesize a Disconnected message */
2732 r = sd_bus_message_new_signal(
2735 "/org/freedesktop/DBus/Local",
2736 "org.freedesktop.DBus.Local",
2741 bus_message_set_sender_local(bus, m);
2743 r = bus_seal_synthetic_message(bus, m);
2749 bus->current_message = m;
2750 bus->iteration_counter++;
2752 r = process_filter(bus, m);
2756 r = process_match(bus, m);
2768 bus->current_message = NULL;
2773 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2774 BUS_DONT_DESTROY(bus);
2777 /* Returns 0 when we didn't do anything. This should cause the
2778 * caller to invoke sd_bus_wait() before returning the next
2779 * time. Returns > 0 when we did something, which possibly
2780 * means *ret is filled in with an unprocessed message. */
2782 assert_return(bus, -EINVAL);
2783 assert_return(!bus_pid_changed(bus), -ECHILD);
2785 /* We don't allow recursively invoking sd_bus_process(). */
2786 assert_return(!bus->current_message, -EBUSY);
2787 assert(!bus->current_slot);
2789 switch (bus->state) {
2798 r = bus_socket_process_opening(bus);
2799 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2800 bus_enter_closing(bus);
2808 case BUS_AUTHENTICATING:
2809 r = bus_socket_process_authenticating(bus);
2810 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2811 bus_enter_closing(bus);
2823 r = process_running(bus, hint_priority, priority, ret);
2824 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2825 bus_enter_closing(bus);
2835 return process_closing(bus, ret);
2838 assert_not_reached("Unknown state");
2841 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2842 return bus_process_internal(bus, false, 0, ret);
2845 /// UNNEEDED by elogind
2847 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2848 return bus_process_internal(bus, true, priority, ret);
2852 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2853 struct pollfd p[2] = {};
2856 usec_t m = USEC_INFINITY;
2860 if (bus->state == BUS_CLOSING)
2863 if (!BUS_IS_OPEN(bus->state))
2866 e = sd_bus_get_events(bus);
2871 /* The caller really needs some more data, he doesn't
2872 * care about what's already read, or any timeouts
2873 * except its own. */
2877 /* The caller wants to process if there's something to
2878 * process, but doesn't care otherwise */
2880 r = sd_bus_get_timeout(bus, &until);
2885 nw = now(CLOCK_MONOTONIC);
2886 m = until > nw ? until - nw : 0;
2890 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2893 p[0].fd = bus->input_fd;
2894 if (bus->output_fd == bus->input_fd) {
2898 p[0].events = e & POLLIN;
2899 p[1].fd = bus->output_fd;
2900 p[1].events = e & POLLOUT;
2904 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2908 return r > 0 ? 1 : 0;
2911 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2913 assert_return(bus, -EINVAL);
2914 assert_return(!bus_pid_changed(bus), -ECHILD);
2916 if (bus->state == BUS_CLOSING)
2919 if (!BUS_IS_OPEN(bus->state))
2922 if (bus->rqueue_size > 0)
2925 return bus_poll(bus, false, timeout_usec);
2928 _public_ int sd_bus_flush(sd_bus *bus) {
2931 assert_return(bus, -EINVAL);
2932 assert_return(!bus_pid_changed(bus), -ECHILD);
2934 if (bus->state == BUS_CLOSING)
2937 if (!BUS_IS_OPEN(bus->state))
2940 r = bus_ensure_running(bus);
2944 if (bus->wqueue_size <= 0)
2948 r = dispatch_wqueue(bus);
2950 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2951 bus_enter_closing(bus);
2958 if (bus->wqueue_size <= 0)
2961 r = bus_poll(bus, false, (uint64_t) -1);
2967 /// UNNEEDED by elogind
2969 _public_ int sd_bus_add_filter(
2972 sd_bus_message_handler_t callback,
2977 assert_return(bus, -EINVAL);
2978 assert_return(callback, -EINVAL);
2979 assert_return(!bus_pid_changed(bus), -ECHILD);
2981 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2985 s->filter_callback.callback = callback;
2987 bus->filter_callbacks_modified = true;
2988 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2997 _public_ int sd_bus_add_match(
3001 sd_bus_message_handler_t callback,
3004 struct bus_match_component *components = NULL;
3005 unsigned n_components = 0;
3006 sd_bus_slot *s = NULL;
3009 assert_return(bus, -EINVAL);
3010 assert_return(match, -EINVAL);
3011 assert_return(!bus_pid_changed(bus), -ECHILD);
3013 r = bus_match_parse(match, &components, &n_components);
3017 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3023 s->match_callback.callback = callback;
3024 s->match_callback.cookie = ++bus->match_cookie;
3026 if (bus->bus_client) {
3027 enum bus_match_scope scope;
3029 scope = bus_match_get_scope(components, n_components);
3031 /* Do not install server-side matches for matches
3032 * against the local service, interface or bus
3034 if (scope != BUS_MATCH_LOCAL) {
3036 if (!bus->is_kernel) {
3037 /* When this is not a kernel transport, we
3038 * store the original match string, so that we
3039 * can use it to remove the match again */
3041 s->match_callback.match_string = strdup(match);
3042 if (!s->match_callback.match_string) {
3048 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3052 s->match_added = true;
3056 bus->match_callbacks_modified = true;
3057 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3066 bus_match_parse_free(components, n_components);
3067 sd_bus_slot_unref(s);
3072 /// UNNEEDED by elogind
3074 int bus_remove_match_by_string(
3077 sd_bus_message_handler_t callback,
3080 struct bus_match_component *components = NULL;
3081 unsigned n_components = 0;
3082 struct match_callback *c;
3085 assert_return(bus, -EINVAL);
3086 assert_return(match, -EINVAL);
3087 assert_return(!bus_pid_changed(bus), -ECHILD);
3089 r = bus_match_parse(match, &components, &n_components);
3093 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3097 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3100 bus_match_parse_free(components, n_components);
3106 bool bus_pid_changed(sd_bus *bus) {
3109 /* We don't support people creating a bus connection and
3110 * keeping it around over a fork(). Let's complain. */
3112 return bus->original_pid != getpid();
3115 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3116 sd_bus *bus = userdata;
3121 r = sd_bus_process(bus, NULL);
3128 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3129 sd_bus *bus = userdata;
3134 r = sd_bus_process(bus, NULL);
3141 static int prepare_callback(sd_event_source *s, void *userdata) {
3142 sd_bus *bus = userdata;
3149 e = sd_bus_get_events(bus);
3153 if (bus->output_fd != bus->input_fd) {
3155 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3159 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3163 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3168 r = sd_bus_get_timeout(bus, &until);
3174 j = sd_event_source_set_time(bus->time_event_source, until);
3179 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3186 static int quit_callback(sd_event_source *event, void *userdata) {
3187 sd_bus *bus = userdata;
3197 static int attach_io_events(sd_bus *bus) {
3202 if (bus->input_fd < 0)
3208 if (!bus->input_io_event_source) {
3209 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3213 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3217 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3221 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3223 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3228 if (bus->output_fd != bus->input_fd) {
3229 assert(bus->output_fd >= 0);
3231 if (!bus->output_io_event_source) {
3232 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3236 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3240 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3242 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3251 static void detach_io_events(sd_bus *bus) {
3254 if (bus->input_io_event_source) {
3255 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3256 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3259 if (bus->output_io_event_source) {
3260 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3261 bus->output_io_event_source = sd_event_source_unref(bus->output_io_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 = attach_io_events(bus);
3312 sd_bus_detach_event(bus);
3316 _public_ int sd_bus_detach_event(sd_bus *bus) {
3317 assert_return(bus, -EINVAL);
3322 detach_io_events(bus);
3324 if (bus->time_event_source) {
3325 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3326 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3329 if (bus->quit_event_source) {
3330 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3331 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3334 bus->event = sd_event_unref(bus->event);
3338 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3339 assert_return(bus, NULL);
3344 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3345 assert_return(bus, NULL);
3347 return bus->current_message;
3350 /// UNNEEDED by elogind
3352 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3353 assert_return(bus, NULL);
3355 return bus->current_slot;
3359 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3360 assert_return(bus, NULL);
3362 return bus->current_handler;
3365 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3366 assert_return(bus, NULL);
3368 return bus->current_userdata;
3371 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3376 assert(default_bus);
3379 return !!*default_bus;
3382 *ret = sd_bus_ref(*default_bus);
3390 b->default_bus_ptr = default_bus;
3398 _public_ int sd_bus_default_system(sd_bus **ret) {
3399 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3403 _public_ int sd_bus_default_user(sd_bus **ret) {
3404 /// elogind does not support user buses
3406 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3408 return sd_bus_default_system(ret);
3412 _public_ int sd_bus_default(sd_bus **ret) {
3416 /* Let's try our best to reuse another cached connection. If
3417 * the starter bus type is set, connect via our normal
3418 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3419 * we can share the connection with the user/system default
3422 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3424 if (streq(e, "system"))
3425 return sd_bus_default_system(ret);
3426 /// 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. */
3436 e = secure_getenv("DBUS_STARTER_ADDRESS");
3439 return bus_default(sd_bus_open, &default_starter_bus, ret);
3442 /* Finally, if nothing is set use the cached connection for
3443 * the right scope */
3445 /// elogind does not support systemd units
3447 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3448 return sd_bus_default_user(ret);
3451 return sd_bus_default_system(ret);
3454 /// UNNEEDED by elogind
3456 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3457 assert_return(b, -EINVAL);
3458 assert_return(tid, -EINVAL);
3459 assert_return(!bus_pid_changed(b), -ECHILD);
3467 return sd_event_get_tid(b->event, tid);
3472 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3473 _cleanup_free_ char *e = NULL;
3476 assert_return(object_path_is_valid(prefix), -EINVAL);
3477 assert_return(external_id, -EINVAL);
3478 assert_return(ret_path, -EINVAL);
3480 e = bus_label_escape(external_id);
3484 ret = strjoin(prefix, "/", e, NULL);
3492 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3496 assert_return(object_path_is_valid(path), -EINVAL);
3497 assert_return(object_path_is_valid(prefix), -EINVAL);
3498 assert_return(external_id, -EINVAL);
3500 e = object_path_startswith(path, prefix);
3502 *external_id = NULL;
3506 ret = bus_label_unescape(e);
3514 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3515 _cleanup_strv_free_ char **labels = NULL;
3516 char *path, *path_pos, **label_pos;
3517 const char *sep, *template_pos;
3522 assert_return(out, -EINVAL);
3523 assert_return(path_template, -EINVAL);
3525 path_length = strlen(path_template);
3527 va_start(list, path_template);
3528 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3532 arg = va_arg(list, const char *);
3538 label = bus_label_escape(arg);
3544 r = strv_consume(&labels, label);
3550 /* add label length, but account for the format character */
3551 path_length += strlen(label) - 1;
3555 path = malloc(path_length + 1);
3562 for (template_pos = path_template; *template_pos; ) {
3563 sep = strchrnul(template_pos, '%');
3564 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3568 path_pos = stpcpy(path_pos, *label_pos++);
3569 template_pos = sep + 1;
3577 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3578 _cleanup_strv_free_ char **labels = NULL;
3579 const char *template_pos, *path_pos;
3585 * This decodes an object-path based on a template argument. The
3586 * template consists of a verbatim path, optionally including special
3589 * - Each occurrence of '%' in the template matches an arbitrary
3590 * substring of a label in the given path. At most one such
3591 * directive is allowed per label. For each such directive, the
3592 * caller must provide an output parameter (char **) via va_arg. If
3593 * NULL is passed, the given label is verified, but not returned.
3594 * For each matched label, the *decoded* label is stored in the
3595 * passed output argument, and the caller is responsible to free
3596 * it. Note that the output arguments are only modified if the
3597 * actualy path matched the template. Otherwise, they're left
3600 * This function returns <0 on error, 0 if the path does not match the
3601 * template, 1 if it matched.
3604 assert_return(path, -EINVAL);
3605 assert_return(path_template, -EINVAL);
3609 for (template_pos = path_template; *template_pos; ) {
3614 /* verify everything until the next '%' matches verbatim */
3615 sep = strchrnul(template_pos, '%');
3616 length = sep - template_pos;
3617 if (strncmp(path_pos, template_pos, length))
3621 template_pos += length;
3626 /* We found the next '%' character. Everything up until here
3627 * matched. We now skip ahead to the end of this label and make
3628 * sure it matches the tail of the label in the path. Then we
3629 * decode the string in-between and save it for later use. */
3631 ++template_pos; /* skip over '%' */
3633 sep = strchrnul(template_pos, '/');
3634 length = sep - template_pos; /* length of suffix to match verbatim */
3636 /* verify the suffixes match */
3637 sep = strchrnul(path_pos, '/');
3638 if (sep - path_pos < (ssize_t)length ||
3639 strncmp(sep - length, template_pos, length))
3642 template_pos += length; /* skip over matched label */
3643 length = sep - path_pos - length; /* length of sub-label to decode */
3645 /* store unescaped label for later use */
3646 label = bus_label_unescape_n(path_pos, length);
3650 r = strv_consume(&labels, label);
3654 path_pos = sep; /* skip decoded label and suffix */
3657 /* end of template must match end of path */
3661 /* copy the labels over to the caller */
3662 va_start(list, path_template);
3663 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3666 arg = va_arg(list, char **);
3679 _public_ int sd_bus_try_close(sd_bus *bus) {
3682 assert_return(bus, -EINVAL);
3683 assert_return(!bus_pid_changed(bus), -ECHILD);
3685 if (!bus->is_kernel)
3688 if (!BUS_IS_OPEN(bus->state))
3691 if (bus->rqueue_size > 0)
3694 if (bus->wqueue_size > 0)
3697 r = bus_kernel_try_close(bus);
3705 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3706 assert_return(bus, -EINVAL);
3707 assert_return(description, -EINVAL);
3708 assert_return(bus->description, -ENXIO);
3709 assert_return(!bus_pid_changed(bus), -ECHILD);
3711 *description = bus->description;
3716 int bus_get_root_path(sd_bus *bus) {
3719 if (bus->cgroup_root)
3722 r = cg_get_root_path(&bus->cgroup_root);
3724 bus->cgroup_root = strdup("/");
3725 if (!bus->cgroup_root)
3734 /// UNNEEDED by elogind
3736 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3739 assert_return(bus, -EINVAL);
3740 assert_return(scope, -EINVAL);
3741 assert_return(!bus_pid_changed(bus), -ECHILD);
3743 if (bus->is_kernel) {
3744 _cleanup_free_ char *n = NULL;
3747 r = bus_kernel_get_bus_name(bus, &n);
3751 if (streq(n, "0-system")) {
3756 dash = strchr(n, '-');
3757 if (streq_ptr(dash, "-user")) {
3768 if (bus->is_system) {
3776 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3778 assert_return(bus, -EINVAL);
3779 assert_return(address, -EINVAL);
3780 assert_return(!bus_pid_changed(bus), -ECHILD);
3783 *address = bus->address;
3790 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3791 assert_return(bus, -EINVAL);
3792 assert_return(mask, -EINVAL);
3793 assert_return(!bus_pid_changed(bus), -ECHILD);
3795 *mask = bus->creds_mask;
3799 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3800 assert_return(bus, -EINVAL);
3801 assert_return(!bus_pid_changed(bus), -ECHILD);
3803 return bus->bus_client;
3806 _public_ int sd_bus_is_server(sd_bus *bus) {
3807 assert_return(bus, -EINVAL);
3808 assert_return(!bus_pid_changed(bus), -ECHILD);
3810 return bus->is_server;
3813 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3814 assert_return(bus, -EINVAL);
3815 assert_return(!bus_pid_changed(bus), -ECHILD);
3817 return bus->anonymous_auth;
3820 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3821 assert_return(bus, -EINVAL);
3822 assert_return(!bus_pid_changed(bus), -ECHILD);
3824 return bus->trusted;
3827 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3828 assert_return(bus, -EINVAL);
3829 assert_return(!bus_pid_changed(bus), -ECHILD);
3831 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3834 static void flush_close(sd_bus *bus) {
3838 /* Flushes and closes the specified bus. We take a ref before,
3839 * to ensure the flushing does not cause the bus to be
3842 sd_bus_flush_close_unref(sd_bus_ref(bus));
3845 _public_ void sd_bus_default_flush_close(void) {
3846 flush_close(default_starter_bus);
3847 flush_close(default_user_bus);
3848 flush_close(default_system_bus);