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/>.
32 #include "alloc-util.h"
33 #include "bus-container.h"
34 #include "bus-control.h"
35 #include "bus-internal.h"
36 #include "bus-kernel.h"
37 #include "bus-label.h"
38 #include "bus-message.h"
39 #include "bus-objects.h"
40 #include "bus-protocol.h"
42 #include "bus-socket.h"
43 #include "bus-track.h"
46 #include "cgroup-util.h"
49 #include "hexdecoct.h"
50 #include "hostname-util.h"
53 #include "parse-util.h"
54 #include "string-util.h"
58 #define log_debug_bus_message(m) \
60 sd_bus_message *_mm = (m); \
61 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
62 bus_message_type_to_string(_mm->header->type), \
63 strna(sd_bus_message_get_sender(_mm)), \
64 strna(sd_bus_message_get_destination(_mm)), \
65 strna(sd_bus_message_get_path(_mm)), \
66 strna(sd_bus_message_get_interface(_mm)), \
67 strna(sd_bus_message_get_member(_mm)), \
68 BUS_MESSAGE_COOKIE(_mm), \
70 strna(_mm->error.message)); \
73 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
74 static int attach_io_events(sd_bus *b);
75 static void detach_io_events(sd_bus *b);
77 static thread_local sd_bus *default_system_bus = NULL;
78 #if 0 /// UNNEEDED by elogind
79 static thread_local sd_bus *default_user_bus = NULL;
81 static thread_local sd_bus *default_starter_bus = NULL;
83 static void bus_close_fds(sd_bus *b) {
88 if (b->input_fd != b->output_fd)
89 safe_close(b->output_fd);
90 b->output_fd = b->input_fd = safe_close(b->input_fd);
93 static void bus_reset_queues(sd_bus *b) {
96 while (b->rqueue_size > 0)
97 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
99 b->rqueue = mfree(b->rqueue);
100 b->rqueue_allocated = 0;
102 while (b->wqueue_size > 0)
103 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
105 b->wqueue = mfree(b->wqueue);
106 b->wqueue_allocated = 0;
109 static void bus_free(sd_bus *b) {
113 assert(!b->track_queue);
115 b->state = BUS_CLOSED;
117 sd_bus_detach_event(b);
119 while ((s = b->slots)) {
120 /* At this point only floating slots can still be
121 * around, because the non-floating ones keep a
122 * reference to the bus, and we thus couldn't be
123 * destructing right now... We forcibly disconnect the
124 * slots here, so that they still can be referenced by
125 * apps, but are dead. */
128 bus_slot_disconnect(s);
129 sd_bus_slot_unref(s);
132 if (b->default_bus_ptr)
133 *b->default_bus_ptr = NULL;
138 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
142 free(b->unique_name);
143 free(b->auth_buffer);
148 free(b->cgroup_root);
149 free(b->description);
152 strv_free(b->exec_argv);
154 close_many(b->fds, b->n_fds);
159 ordered_hashmap_free_free(b->reply_callbacks);
160 prioq_free(b->reply_callbacks_prioq);
162 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
163 bus_match_free(&b->match_callbacks);
165 hashmap_free_free(b->vtable_methods);
166 hashmap_free_free(b->vtable_properties);
168 assert(hashmap_isempty(b->nodes));
169 hashmap_free(b->nodes);
171 bus_kernel_flush_memfd(b);
173 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
178 _public_ int sd_bus_new(sd_bus **ret) {
181 assert_return(ret, -EINVAL);
187 r->n_ref = REFCNT_INIT;
188 r->input_fd = r->output_fd = -1;
189 r->message_version = 1;
190 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
191 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
192 r->attach_flags |= KDBUS_ATTACH_NAMES;
193 r->original_pid = getpid();
195 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
197 /* We guarantee that wqueue always has space for at least one
199 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
208 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
211 assert_return(bus, -EINVAL);
212 assert_return(bus->state == BUS_UNSET, -EPERM);
213 assert_return(address, -EINVAL);
214 assert_return(!bus_pid_changed(bus), -ECHILD);
226 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
227 assert_return(bus, -EINVAL);
228 assert_return(bus->state == BUS_UNSET, -EPERM);
229 assert_return(input_fd >= 0, -EBADF);
230 assert_return(output_fd >= 0, -EBADF);
231 assert_return(!bus_pid_changed(bus), -ECHILD);
233 bus->input_fd = input_fd;
234 bus->output_fd = output_fd;
238 #if 0 /// UNNEEDED by elogind
239 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
242 assert_return(bus, -EINVAL);
243 assert_return(bus->state == BUS_UNSET, -EPERM);
244 assert_return(path, -EINVAL);
245 assert_return(!strv_isempty(argv), -EINVAL);
246 assert_return(!bus_pid_changed(bus), -ECHILD);
258 free(bus->exec_path);
259 strv_free(bus->exec_argv);
267 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
268 assert_return(bus, -EINVAL);
269 assert_return(bus->state == BUS_UNSET, -EPERM);
270 assert_return(!bus_pid_changed(bus), -ECHILD);
272 bus->bus_client = !!b;
276 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
277 assert_return(bus, -EINVAL);
278 assert_return(bus->state == BUS_UNSET, -EPERM);
279 assert_return(!bus_pid_changed(bus), -ECHILD);
281 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
285 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
286 assert_return(bus, -EINVAL);
287 assert_return(bus->state == BUS_UNSET, -EPERM);
288 assert_return(!bus_pid_changed(bus), -ECHILD);
290 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
294 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
296 assert_return(bus, -EINVAL);
297 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
298 assert_return(!bus_pid_changed(bus), -ECHILD);
300 new_flags = bus->attach_flags;
301 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
303 if (bus->attach_flags == new_flags)
306 bus->attach_flags = new_flags;
307 if (bus->state != BUS_UNSET && bus->is_kernel)
308 bus_kernel_realize_attach_flags(bus);
313 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
316 assert_return(bus, -EINVAL);
317 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
318 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
319 assert_return(!bus_pid_changed(bus), -ECHILD);
322 bus->creds_mask |= mask;
324 bus->creds_mask &= ~mask;
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;
329 /* Make sure we don't lose the timestamp flag */
330 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
331 if (bus->attach_flags == new_flags)
334 bus->attach_flags = new_flags;
335 if (bus->state != BUS_UNSET && bus->is_kernel)
336 bus_kernel_realize_attach_flags(bus);
341 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
342 assert_return(bus, -EINVAL);
343 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
344 assert_return(bus->state == BUS_UNSET, -EPERM);
345 assert_return(!bus_pid_changed(bus), -ECHILD);
347 bus->is_server = !!b;
348 bus->server_id = server_id;
352 _public_ int sd_bus_set_anonymous(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);
357 bus->anonymous_auth = !!b;
361 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
362 assert_return(bus, -EINVAL);
363 assert_return(bus->state == BUS_UNSET, -EPERM);
364 assert_return(!bus_pid_changed(bus), -ECHILD);
370 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
371 assert_return(bus, -EINVAL);
372 assert_return(bus->state == BUS_UNSET, -EPERM);
373 assert_return(!bus_pid_changed(bus), -ECHILD);
375 return free_and_strdup(&bus->description, description);
379 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
380 assert_return(bus, -EINVAL);
381 assert_return(!bus_pid_changed(bus), -ECHILD);
383 bus->allow_interactive_authorization = !!b;
387 #if 0 /// UNNEEDED by elogind
388 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
389 assert_return(bus, -EINVAL);
390 assert_return(!bus_pid_changed(bus), -ECHILD);
392 return bus->allow_interactive_authorization;
396 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
404 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
406 r = sd_bus_message_get_errno(reply);
410 r = sd_bus_message_read(reply, "s", &s);
414 if (!service_name_is_valid(s) || s[0] != ':')
417 bus->unique_name = strdup(s);
418 if (!bus->unique_name)
421 if (bus->state == BUS_HELLO)
422 bus->state = BUS_RUNNING;
427 static int bus_send_hello(sd_bus *bus) {
428 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
433 if (!bus->bus_client || bus->is_kernel)
436 r = sd_bus_message_new_method_call(
439 "org.freedesktop.DBus",
440 "/org/freedesktop/DBus",
441 "org.freedesktop.DBus",
446 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
449 int bus_start_running(sd_bus *bus) {
452 if (bus->bus_client && !bus->is_kernel) {
453 bus->state = BUS_HELLO;
457 bus->state = BUS_RUNNING;
461 static int parse_address_key(const char **p, const char *key, char **value) {
462 size_t l, n = 0, allocated = 0;
472 if (strncmp(*p, key, l) != 0)
485 while (*a != ';' && *a != ',' && *a != 0) {
503 c = (char) ((x << 4) | y);
510 if (!GREEDY_REALLOC(r, allocated, n + 2))
534 static void skip_address_key(const char **p) {
538 *p += strcspn(*p, ",");
544 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
545 _cleanup_free_ char *path = NULL, *abstract = NULL;
554 while (**p != 0 && **p != ';') {
555 r = parse_address_key(p, "guid", guid);
561 r = parse_address_key(p, "path", &path);
567 r = parse_address_key(p, "abstract", &abstract);
576 if (!path && !abstract)
579 if (path && abstract)
584 if (l > sizeof(b->sockaddr.un.sun_path))
587 b->sockaddr.un.sun_family = AF_UNIX;
588 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
589 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
590 } else if (abstract) {
591 l = strlen(abstract);
592 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
595 b->sockaddr.un.sun_family = AF_UNIX;
596 b->sockaddr.un.sun_path[0] = 0;
597 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
598 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
604 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
605 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
607 struct addrinfo *result, hints = {
608 .ai_socktype = SOCK_STREAM,
609 .ai_flags = AI_ADDRCONFIG,
617 while (**p != 0 && **p != ';') {
618 r = parse_address_key(p, "guid", guid);
624 r = parse_address_key(p, "host", &host);
630 r = parse_address_key(p, "port", &port);
636 r = parse_address_key(p, "family", &family);
649 if (streq(family, "ipv4"))
650 hints.ai_family = AF_INET;
651 else if (streq(family, "ipv6"))
652 hints.ai_family = AF_INET6;
657 r = getaddrinfo(host, port, &hints, &result);
661 return -EADDRNOTAVAIL;
663 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
664 b->sockaddr_size = result->ai_addrlen;
666 freeaddrinfo(result);
671 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
673 unsigned n_argv = 0, j;
675 size_t allocated = 0;
683 while (**p != 0 && **p != ';') {
684 r = parse_address_key(p, "guid", guid);
690 r = parse_address_key(p, "path", &path);
696 if (startswith(*p, "argv")) {
700 ul = strtoul(*p + 4, (char**) p, 10);
701 if (errno > 0 || **p != '=' || ul > 256) {
709 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
717 r = parse_address_key(p, NULL, argv + ul);
732 /* Make sure there are no holes in the array, with the
733 * exception of argv[0] */
734 for (j = 1; j < n_argv; j++)
740 if (argv && argv[0] == NULL) {
741 argv[0] = strdup(path);
753 for (j = 0; j < n_argv; j++)
761 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
762 _cleanup_free_ char *path = NULL;
770 while (**p != 0 && **p != ';') {
771 r = parse_address_key(p, "guid", guid);
777 r = parse_address_key(p, "path", &path);
796 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
797 _cleanup_free_ char *machine = NULL, *pid = NULL;
805 while (**p != 0 && **p != ';') {
806 r = parse_address_key(p, "guid", guid);
812 r = parse_address_key(p, "machine", &machine);
818 r = parse_address_key(p, "pid", &pid);
827 if (!machine == !pid)
831 if (!machine_name_is_valid(machine))
835 b->machine = machine;
838 b->machine = mfree(b->machine);
842 r = parse_pid(pid, &b->nspid);
848 b->sockaddr.un.sun_family = AF_UNIX;
849 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
850 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
855 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
856 _cleanup_free_ char *machine = NULL, *pid = NULL;
864 while (**p != 0 && **p != ';') {
865 r = parse_address_key(p, "guid", guid);
871 r = parse_address_key(p, "machine", &machine);
877 r = parse_address_key(p, "pid", &pid);
886 if (!machine == !pid)
890 if (!machine_name_is_valid(machine))
894 b->machine = machine;
897 b->machine = mfree(b->machine);
901 r = parse_pid(pid, &b->nspid);
907 r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
914 static void bus_reset_parsed_address(sd_bus *b) {
918 b->sockaddr_size = 0;
919 b->exec_argv = strv_free(b->exec_argv);
920 b->exec_path = mfree(b->exec_path);
921 b->server_id = SD_ID128_NULL;
922 b->kernel = mfree(b->kernel);
923 b->machine = mfree(b->machine);
927 static int bus_parse_next_address(sd_bus *b) {
928 _cleanup_free_ char *guid = NULL;
936 if (b->address[b->address_index] == 0)
939 bus_reset_parsed_address(b);
941 a = b->address + b->address_index;
950 if (startswith(a, "unix:")) {
953 r = parse_unix_address(b, &a, &guid);
958 } else if (startswith(a, "tcp:")) {
961 r = parse_tcp_address(b, &a, &guid);
967 } else if (startswith(a, "unixexec:")) {
970 r = parse_exec_address(b, &a, &guid);
976 } else if (startswith(a, "kernel:")) {
979 r = parse_kernel_address(b, &a, &guid);
984 } else if (startswith(a, "x-machine-unix:")) {
987 r = parse_container_unix_address(b, &a, &guid);
992 } else if (startswith(a, "x-machine-kernel:")) {
995 r = parse_container_kernel_address(b, &a, &guid);
1008 r = sd_id128_from_string(guid, &b->server_id);
1013 b->address_index = a - b->address;
1017 static int bus_start_address(sd_bus *b) {
1018 bool container_kdbus_available = false;
1019 bool kdbus_available = false;
1025 bool skipped = false;
1030 * Usually, if you provide multiple different bus-addresses, we
1031 * try all of them in order. We use the first one that
1032 * succeeds. However, if you mix kernel and unix addresses, we
1033 * never try unix-addresses if a previous kernel address was
1034 * tried and kdbus was available. This is required to prevent
1035 * clients to fallback to the bus-proxy if kdbus is available
1036 * but failed (eg., too many connections).
1040 r = bus_socket_exec(b);
1041 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1042 r = bus_container_connect_kernel(b);
1043 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1044 container_kdbus_available = true;
1046 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1047 if (!container_kdbus_available)
1048 r = bus_container_connect_socket(b);
1052 } else if (b->kernel) {
1053 r = bus_kernel_connect(b);
1054 if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1055 kdbus_available = true;
1057 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1058 if (!kdbus_available)
1059 r = bus_socket_connect(b);
1067 r = attach_io_events(b);
1072 b->last_connect_error = -r;
1075 r = bus_parse_next_address(b);
1079 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1083 int bus_next_address(sd_bus *b) {
1086 bus_reset_parsed_address(b);
1087 return bus_start_address(b);
1090 static int bus_start_fd(sd_bus *b) {
1095 assert(b->input_fd >= 0);
1096 assert(b->output_fd >= 0);
1098 r = fd_nonblock(b->input_fd, true);
1102 r = fd_cloexec(b->input_fd, true);
1106 if (b->input_fd != b->output_fd) {
1107 r = fd_nonblock(b->output_fd, true);
1111 r = fd_cloexec(b->output_fd, true);
1116 if (fstat(b->input_fd, &st) < 0)
1119 if (S_ISCHR(b->input_fd))
1120 return bus_kernel_take_fd(b);
1122 return bus_socket_take_fd(b);
1125 _public_ int sd_bus_start(sd_bus *bus) {
1128 assert_return(bus, -EINVAL);
1129 assert_return(bus->state == BUS_UNSET, -EPERM);
1130 assert_return(!bus_pid_changed(bus), -ECHILD);
1132 bus->state = BUS_OPENING;
1134 if (bus->is_server && bus->bus_client)
1137 if (bus->input_fd >= 0)
1138 r = bus_start_fd(bus);
1139 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1140 r = bus_start_address(bus);
1149 return bus_send_hello(bus);
1152 _public_ int sd_bus_open(sd_bus **ret) {
1157 assert_return(ret, -EINVAL);
1159 /* Let's connect to the starter bus if it is set, and
1160 * otherwise to the bus that is appropropriate for the scope
1161 * we are running in */
1163 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1165 if (streq(e, "system"))
1166 return sd_bus_open_system(ret);
1167 #if 0 /// elogind does not support systemd units
1168 else if (STR_IN_SET(e, "session", "user"))
1169 return sd_bus_open_user(ret);
1173 e = secure_getenv("DBUS_STARTER_ADDRESS");
1175 #if 0 /// elogind does not support systemd units
1176 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1177 return sd_bus_open_user(ret);
1180 return sd_bus_open_system(ret);
1187 r = sd_bus_set_address(b, e);
1191 b->bus_client = true;
1193 /* We don't know whether the bus is trusted or not, so better
1194 * be safe, and authenticate everything */
1196 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1197 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1199 r = sd_bus_start(b);
1211 int bus_set_address_system(sd_bus *b) {
1215 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1217 return sd_bus_set_address(b, e);
1219 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1222 _public_ int sd_bus_open_system(sd_bus **ret) {
1226 assert_return(ret, -EINVAL);
1232 r = bus_set_address_system(b);
1236 b->bus_client = true;
1237 b->is_system = true;
1239 /* Let's do per-method access control on the system bus. We
1240 * need the caller's UID and capability set for that. */
1242 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1243 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1245 r = sd_bus_start(b);
1257 #if 0 /// elogind can not open/use a user bus
1258 int bus_set_address_user(sd_bus *b) {
1265 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1267 return sd_bus_set_address(b, e);
1269 r = cg_pid_get_owner_uid(0, &uid);
1273 e = secure_getenv("XDG_RUNTIME_DIR");
1275 _cleanup_free_ char *ee = NULL;
1277 ee = bus_address_escape(e);
1281 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1283 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1292 _public_ int sd_bus_open_user(sd_bus **ret) {
1293 #if 0 /// elogind does not support user buses
1297 assert_return(ret, -EINVAL);
1303 r = bus_set_address_user(b);
1307 b->bus_client = true;
1310 /* We don't do any per-method access control on the user
1314 r = sd_bus_start(b);
1325 return sd_bus_open_system(ret);
1329 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1330 _cleanup_free_ char *e = NULL;
1331 char *m = NULL, *c = NULL;
1336 /* Let's see if we shall enter some container */
1337 m = strchr(host, ':');
1341 /* Let's make sure this is not a port of some kind,
1342 * and is a valid machine name. */
1343 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1346 /* Cut out the host part */
1347 t = strndupa(host, m - host - 1);
1348 e = bus_address_escape(t);
1352 c = strjoina(",argv4=--machine=", m);
1357 e = bus_address_escape(host);
1362 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1369 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1373 assert_return(host, -EINVAL);
1374 assert_return(ret, -EINVAL);
1376 r = sd_bus_new(&bus);
1380 r = bus_set_address_system_remote(bus, host);
1384 bus->bus_client = true;
1385 bus->trusted = false;
1386 bus->is_system = true;
1388 r = sd_bus_start(bus);
1400 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1401 _cleanup_free_ char *e = NULL;
1406 e = bus_address_escape(machine);
1410 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1417 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1421 assert_return(machine, -EINVAL);
1422 assert_return(ret, -EINVAL);
1423 assert_return(machine_name_is_valid(machine), -EINVAL);
1425 r = sd_bus_new(&bus);
1429 r = bus_set_address_system_machine(bus, machine);
1433 bus->bus_client = true;
1434 bus->trusted = false;
1435 bus->is_system = true;
1437 r = sd_bus_start(bus);
1449 _public_ void sd_bus_close(sd_bus *bus) {
1453 if (bus->state == BUS_CLOSED)
1455 if (bus_pid_changed(bus))
1458 bus->state = BUS_CLOSED;
1460 sd_bus_detach_event(bus);
1462 /* Drop all queued messages so that they drop references to
1463 * the bus object and the bus may be freed */
1464 bus_reset_queues(bus);
1466 if (!bus->is_kernel)
1469 /* We'll leave the fd open in case this is a kernel bus, since
1470 * there might still be memblocks around that reference this
1471 * bus, and they might need to invoke the KDBUS_CMD_FREE
1472 * ioctl on the fd when they are freed. */
1475 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1483 return sd_bus_unref(bus);
1486 static void bus_enter_closing(sd_bus *bus) {
1489 if (bus->state != BUS_OPENING &&
1490 bus->state != BUS_AUTHENTICATING &&
1491 bus->state != BUS_HELLO &&
1492 bus->state != BUS_RUNNING)
1495 bus->state = BUS_CLOSING;
1498 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1499 assert_return(bus, NULL);
1501 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1506 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1512 i = REFCNT_DEC(bus->n_ref);
1520 #if 0 /// 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 #if 0 /// UNNEEDED by elogind
1555 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1558 assert_return(bus, -EINVAL);
1559 assert_return(id, -EINVAL);
1560 assert_return(!bus_pid_changed(bus), -ECHILD);
1562 r = bus_ensure_running(bus);
1566 *id = bus->server_id;
1571 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1576 /* If we copy the same message to multiple
1577 * destinations, avoid using the same cookie
1579 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1584 timeout = BUS_DEFAULT_TIMEOUT;
1586 return bus_message_seal(m, ++b->cookie, timeout);
1589 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1590 bool remarshal = false;
1594 /* wrong packet version */
1595 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1598 /* wrong packet endianness */
1599 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1602 /* TODO: kdbus-messages received from the kernel contain data which is
1603 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1604 * force remarshaling of the message. Technically, we could just
1605 * recreate the kdbus message, but that is non-trivial as other parts of
1606 * the message refer to m->kdbus already. This should be fixed! */
1607 if ((*m)->kdbus && (*m)->release_kdbus)
1610 return remarshal ? bus_message_remarshal(b, m) : 0;
1613 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1617 /* Fake some timestamps, if they were requested, and not
1618 * already initialized */
1619 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1620 if (m->realtime <= 0)
1621 m->realtime = now(CLOCK_REALTIME);
1623 if (m->monotonic <= 0)
1624 m->monotonic = now(CLOCK_MONOTONIC);
1627 /* The bus specification says the serial number cannot be 0,
1628 * hence let's fill something in for synthetic messages. Since
1629 * synthetic messages might have a fake sender and we don't
1630 * want to interfere with the real sender's serial numbers we
1631 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1632 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1633 * even though kdbus can do 64bit. */
1634 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1637 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1644 r = bus_kernel_write_message(bus, m, hint_sync_call);
1646 r = bus_socket_write_message(bus, m, idx);
1651 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1652 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1653 bus_message_type_to_string(m->header->type),
1654 strna(sd_bus_message_get_sender(m)),
1655 strna(sd_bus_message_get_destination(m)),
1656 strna(sd_bus_message_get_path(m)),
1657 strna(sd_bus_message_get_interface(m)),
1658 strna(sd_bus_message_get_member(m)),
1659 BUS_MESSAGE_COOKIE(m),
1661 strna(m->error.message));
1666 static int dispatch_wqueue(sd_bus *bus) {
1670 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1672 while (bus->wqueue_size > 0) {
1674 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1678 /* Didn't do anything this time */
1680 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1681 /* Fully written. Let's drop the entry from
1684 * This isn't particularly optimized, but
1685 * well, this is supposed to be our worst-case
1686 * buffer only, and the socket buffer is
1687 * supposed to be our primary buffer, and if
1688 * it got full, then all bets are off
1691 bus->wqueue_size --;
1692 sd_bus_message_unref(bus->wqueue[0]);
1693 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1703 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1707 return bus_kernel_read_message(bus, hint_priority, priority);
1709 return bus_socket_read_message(bus);
1712 int bus_rqueue_make_room(sd_bus *bus) {
1715 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1718 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1724 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1729 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1731 /* Note that the priority logic is only available on kdbus,
1732 * where the rqueue is unused. We check the rqueue here
1733 * anyway, because it's simple... */
1736 if (bus->rqueue_size > 0) {
1737 /* Dispatch a queued message */
1739 *m = bus->rqueue[0];
1740 bus->rqueue_size --;
1741 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1745 /* Try to read a new message */
1746 r = bus_read_message(bus, hint_priority, priority);
1756 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1757 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1760 assert_return(m, -EINVAL);
1765 assert_return(!bus_pid_changed(bus), -ECHILD);
1766 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1768 if (!BUS_IS_OPEN(bus->state))
1772 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1779 /* If the cookie number isn't kept, then we know that no reply
1781 if (!cookie && !m->sealed)
1782 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1784 r = bus_seal_message(bus, m, 0);
1788 /* Remarshall if we have to. This will possibly unref the
1789 * message and place a replacement in m */
1790 r = bus_remarshal_message(bus, &m);
1794 /* If this is a reply and no reply was requested, then let's
1795 * suppress this, if we can */
1799 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1802 r = bus_write_message(bus, m, hint_sync_call, &idx);
1804 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1805 bus_enter_closing(bus);
1812 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1813 /* Wasn't fully written. So let's remember how
1814 * much was written. Note that the first entry
1815 * of the wqueue array is always allocated so
1816 * that we always can remember how much was
1818 bus->wqueue[0] = sd_bus_message_ref(m);
1819 bus->wqueue_size = 1;
1824 /* Just append it to the queue. */
1826 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1829 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1832 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1837 *cookie = BUS_MESSAGE_COOKIE(m);
1842 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1843 return bus_send_internal(bus, m, cookie, false);
1846 #if 0 /// UNNEEDED by elogind
1847 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1850 assert_return(m, -EINVAL);
1855 assert_return(!bus_pid_changed(bus), -ECHILD);
1857 if (!BUS_IS_OPEN(bus->state))
1860 if (!streq_ptr(m->destination, destination)) {
1865 r = sd_bus_message_set_destination(m, destination);
1870 return sd_bus_send(bus, m, cookie);
1874 static usec_t calc_elapse(uint64_t usec) {
1875 if (usec == (uint64_t) -1)
1878 return now(CLOCK_MONOTONIC) + usec;
1881 static int timeout_compare(const void *a, const void *b) {
1882 const struct reply_callback *x = a, *y = b;
1884 if (x->timeout != 0 && y->timeout == 0)
1887 if (x->timeout == 0 && y->timeout != 0)
1890 if (x->timeout < y->timeout)
1893 if (x->timeout > y->timeout)
1899 _public_ int sd_bus_call_async(
1903 sd_bus_message_handler_t callback,
1907 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1908 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1911 assert_return(m, -EINVAL);
1912 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1913 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1914 assert_return(callback, -EINVAL);
1919 assert_return(!bus_pid_changed(bus), -ECHILD);
1920 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1922 if (!BUS_IS_OPEN(bus->state))
1925 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1929 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1933 r = bus_seal_message(bus, m, usec);
1937 r = bus_remarshal_message(bus, &m);
1941 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1945 s->reply_callback.callback = callback;
1947 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1948 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1950 s->reply_callback.cookie = 0;
1954 s->reply_callback.timeout = calc_elapse(m->timeout);
1955 if (s->reply_callback.timeout != 0) {
1956 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1958 s->reply_callback.timeout = 0;
1963 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1974 int bus_ensure_running(sd_bus *bus) {
1979 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1981 if (bus->state == BUS_RUNNING)
1985 r = sd_bus_process(bus, NULL);
1988 if (bus->state == BUS_RUNNING)
1993 r = sd_bus_wait(bus, (uint64_t) -1);
1999 _public_ int sd_bus_call(
2003 sd_bus_error *error,
2004 sd_bus_message **reply) {
2006 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2012 bus_assert_return(m, -EINVAL, error);
2013 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2014 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2015 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2020 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2021 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2023 if (!BUS_IS_OPEN(bus->state)) {
2028 r = bus_ensure_running(bus);
2032 i = bus->rqueue_size;
2034 r = bus_seal_message(bus, m, usec);
2038 r = bus_remarshal_message(bus, &m);
2042 r = bus_send_internal(bus, m, &cookie, true);
2046 timeout = calc_elapse(m->timeout);
2051 while (i < bus->rqueue_size) {
2052 sd_bus_message *incoming = NULL;
2054 incoming = bus->rqueue[i];
2056 if (incoming->reply_cookie == cookie) {
2057 /* Found a match! */
2059 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2061 log_debug_bus_message(incoming);
2063 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2065 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2069 sd_bus_message_unref(incoming);
2074 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2075 sd_bus_message_unref(incoming);
2078 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2079 r = sd_bus_error_copy(error, &incoming->error);
2080 sd_bus_message_unref(incoming);
2087 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2090 streq(bus->unique_name, incoming->sender)) {
2092 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2095 /* Our own message? Somebody is trying
2096 * to send its own client a message,
2097 * let's not dead-lock, let's fail
2100 sd_bus_message_unref(incoming);
2105 /* Try to read more, right-away */
2109 r = bus_read_message(bus, false, 0);
2111 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2112 bus_enter_closing(bus);
2124 n = now(CLOCK_MONOTONIC);
2132 left = (uint64_t) -1;
2134 r = bus_poll(bus, true, left);
2142 r = dispatch_wqueue(bus);
2144 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2145 bus_enter_closing(bus);
2154 return sd_bus_error_set_errno(error, r);
2157 #if 0 /// UNNEEDED by elogind
2158 _public_ int sd_bus_get_fd(sd_bus *bus) {
2160 assert_return(bus, -EINVAL);
2161 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2162 assert_return(!bus_pid_changed(bus), -ECHILD);
2164 return bus->input_fd;
2168 _public_ int sd_bus_get_events(sd_bus *bus) {
2171 assert_return(bus, -EINVAL);
2172 assert_return(!bus_pid_changed(bus), -ECHILD);
2174 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2177 if (bus->state == BUS_OPENING)
2179 else if (bus->state == BUS_AUTHENTICATING) {
2181 if (bus_socket_auth_needs_write(bus))
2186 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2187 if (bus->rqueue_size <= 0)
2189 if (bus->wqueue_size > 0)
2196 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2197 struct reply_callback *c;
2199 assert_return(bus, -EINVAL);
2200 assert_return(timeout_usec, -EINVAL);
2201 assert_return(!bus_pid_changed(bus), -ECHILD);
2203 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2206 if (bus->track_queue) {
2211 if (bus->state == BUS_CLOSING) {
2216 if (bus->state == BUS_AUTHENTICATING) {
2217 *timeout_usec = bus->auth_timeout;
2221 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2222 *timeout_usec = (uint64_t) -1;
2226 if (bus->rqueue_size > 0) {
2231 c = prioq_peek(bus->reply_callbacks_prioq);
2233 *timeout_usec = (uint64_t) -1;
2237 if (c->timeout == 0) {
2238 *timeout_usec = (uint64_t) -1;
2242 *timeout_usec = c->timeout;
2246 static int process_timeout(sd_bus *bus) {
2247 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2248 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2249 struct reply_callback *c;
2256 c = prioq_peek(bus->reply_callbacks_prioq);
2260 n = now(CLOCK_MONOTONIC);
2264 r = bus_message_new_synthetic_error(
2267 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2272 r = bus_seal_synthetic_message(bus, m);
2276 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2279 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2282 slot = container_of(c, sd_bus_slot, reply_callback);
2284 bus->iteration_counter ++;
2286 bus->current_message = m;
2287 bus->current_slot = sd_bus_slot_ref(slot);
2288 bus->current_handler = c->callback;
2289 bus->current_userdata = slot->userdata;
2290 r = c->callback(m, slot->userdata, &error_buffer);
2291 bus->current_userdata = NULL;
2292 bus->current_handler = NULL;
2293 bus->current_slot = NULL;
2294 bus->current_message = NULL;
2296 if (slot->floating) {
2297 bus_slot_disconnect(slot);
2298 sd_bus_slot_unref(slot);
2301 sd_bus_slot_unref(slot);
2303 return bus_maybe_reply_error(m, r, &error_buffer);
2306 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2310 if (bus->state != BUS_HELLO)
2313 /* Let's make sure the first message on the bus is the HELLO
2314 * reply. But note that we don't actually parse the message
2315 * here (we leave that to the usual handling), we just verify
2316 * we don't let any earlier msg through. */
2318 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2319 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2322 if (m->reply_cookie != 1)
2328 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2329 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2330 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2331 struct reply_callback *c;
2338 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2339 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2342 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2345 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2348 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2354 slot = container_of(c, sd_bus_slot, reply_callback);
2356 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2358 /* If the reply contained a file descriptor which we
2359 * didn't want we pass an error instead. */
2361 r = bus_message_new_synthetic_error(
2364 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2369 /* Copy over original timestamp */
2370 synthetic_reply->realtime = m->realtime;
2371 synthetic_reply->monotonic = m->monotonic;
2372 synthetic_reply->seqnum = m->seqnum;
2374 r = bus_seal_synthetic_message(bus, synthetic_reply);
2378 m = synthetic_reply;
2380 r = sd_bus_message_rewind(m, true);
2385 if (c->timeout != 0) {
2386 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2390 bus->current_slot = sd_bus_slot_ref(slot);
2391 bus->current_handler = c->callback;
2392 bus->current_userdata = slot->userdata;
2393 r = c->callback(m, slot->userdata, &error_buffer);
2394 bus->current_userdata = NULL;
2395 bus->current_handler = NULL;
2396 bus->current_slot = NULL;
2398 if (slot->floating) {
2399 bus_slot_disconnect(slot);
2400 sd_bus_slot_unref(slot);
2403 sd_bus_slot_unref(slot);
2405 return bus_maybe_reply_error(m, r, &error_buffer);
2408 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2409 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2410 struct filter_callback *l;
2417 bus->filter_callbacks_modified = false;
2419 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2422 if (bus->filter_callbacks_modified)
2425 /* Don't run this more than once per iteration */
2426 if (l->last_iteration == bus->iteration_counter)
2429 l->last_iteration = bus->iteration_counter;
2431 r = sd_bus_message_rewind(m, true);
2435 slot = container_of(l, sd_bus_slot, filter_callback);
2437 bus->current_slot = sd_bus_slot_ref(slot);
2438 bus->current_handler = l->callback;
2439 bus->current_userdata = slot->userdata;
2440 r = l->callback(m, slot->userdata, &error_buffer);
2441 bus->current_userdata = NULL;
2442 bus->current_handler = NULL;
2443 bus->current_slot = sd_bus_slot_unref(slot);
2445 r = bus_maybe_reply_error(m, r, &error_buffer);
2451 } while (bus->filter_callbacks_modified);
2456 static int process_match(sd_bus *bus, sd_bus_message *m) {
2463 bus->match_callbacks_modified = false;
2465 r = bus_match_run(bus, &bus->match_callbacks, m);
2469 } while (bus->match_callbacks_modified);
2474 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2475 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2481 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2484 if (bus->manual_peer_interface)
2487 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2490 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2493 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2496 if (streq_ptr(m->member, "Ping"))
2497 r = sd_bus_message_new_method_return(m, &reply);
2498 else if (streq_ptr(m->member, "GetMachineId")) {
2502 r = sd_id128_get_machine(&id);
2506 r = sd_bus_message_new_method_return(m, &reply);
2510 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2512 r = sd_bus_message_new_method_errorf(
2514 SD_BUS_ERROR_UNKNOWN_METHOD,
2515 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2521 r = sd_bus_send(bus, reply, NULL);
2528 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2532 /* If we got a message with a file descriptor which we didn't
2533 * want to accept, then let's drop it. How can this even
2534 * happen? For example, when the kernel queues a message into
2535 * an activatable names's queue which allows fds, and then is
2536 * delivered to us later even though we ourselves did not
2539 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2545 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2548 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2549 return 1; /* just eat it up */
2551 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2554 static int process_message(sd_bus *bus, sd_bus_message *m) {
2560 bus->current_message = m;
2561 bus->iteration_counter++;
2563 log_debug_bus_message(m);
2565 r = process_hello(bus, m);
2569 r = process_reply(bus, m);
2573 r = process_fd_check(bus, m);
2577 r = process_filter(bus, m);
2581 r = process_match(bus, m);
2585 r = process_builtin(bus, m);
2589 r = bus_process_object(bus, m);
2592 bus->current_message = NULL;
2596 static int dispatch_track(sd_bus *bus) {
2599 if (!bus->track_queue)
2602 bus_track_dispatch(bus->track_queue);
2606 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2607 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2611 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2613 r = process_timeout(bus);
2617 r = dispatch_wqueue(bus);
2621 r = dispatch_track(bus);
2625 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2631 r = process_message(bus, m);
2636 r = sd_bus_message_rewind(m, true);
2645 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2647 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2648 strna(sd_bus_message_get_sender(m)),
2649 strna(sd_bus_message_get_path(m)),
2650 strna(sd_bus_message_get_interface(m)),
2651 strna(sd_bus_message_get_member(m)));
2653 r = sd_bus_reply_method_errorf(
2655 SD_BUS_ERROR_UNKNOWN_OBJECT,
2656 "Unknown object '%s'.", m->path);
2670 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2671 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2672 struct reply_callback *c;
2676 assert(bus->state == BUS_CLOSING);
2678 c = ordered_hashmap_first(bus->reply_callbacks);
2680 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2683 /* First, fail all outstanding method calls */
2684 r = bus_message_new_synthetic_error(
2687 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2692 r = bus_seal_synthetic_message(bus, m);
2696 if (c->timeout != 0) {
2697 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2701 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2704 slot = container_of(c, sd_bus_slot, reply_callback);
2706 bus->iteration_counter++;
2708 bus->current_message = m;
2709 bus->current_slot = sd_bus_slot_ref(slot);
2710 bus->current_handler = c->callback;
2711 bus->current_userdata = slot->userdata;
2712 r = c->callback(m, slot->userdata, &error_buffer);
2713 bus->current_userdata = NULL;
2714 bus->current_handler = NULL;
2715 bus->current_slot = NULL;
2716 bus->current_message = NULL;
2718 if (slot->floating) {
2719 bus_slot_disconnect(slot);
2720 sd_bus_slot_unref(slot);
2723 sd_bus_slot_unref(slot);
2725 return bus_maybe_reply_error(m, r, &error_buffer);
2728 /* Then, synthesize a Disconnected message */
2729 r = sd_bus_message_new_signal(
2732 "/org/freedesktop/DBus/Local",
2733 "org.freedesktop.DBus.Local",
2738 bus_message_set_sender_local(bus, m);
2740 r = bus_seal_synthetic_message(bus, m);
2746 bus->current_message = m;
2747 bus->iteration_counter++;
2749 r = process_filter(bus, m);
2753 r = process_match(bus, m);
2765 bus->current_message = NULL;
2770 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2771 BUS_DONT_DESTROY(bus);
2774 /* Returns 0 when we didn't do anything. This should cause the
2775 * caller to invoke sd_bus_wait() before returning the next
2776 * time. Returns > 0 when we did something, which possibly
2777 * means *ret is filled in with an unprocessed message. */
2779 assert_return(bus, -EINVAL);
2780 assert_return(!bus_pid_changed(bus), -ECHILD);
2782 /* We don't allow recursively invoking sd_bus_process(). */
2783 assert_return(!bus->current_message, -EBUSY);
2784 assert(!bus->current_slot);
2786 switch (bus->state) {
2795 r = bus_socket_process_opening(bus);
2796 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2797 bus_enter_closing(bus);
2805 case BUS_AUTHENTICATING:
2806 r = bus_socket_process_authenticating(bus);
2807 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2808 bus_enter_closing(bus);
2820 r = process_running(bus, hint_priority, priority, ret);
2821 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2822 bus_enter_closing(bus);
2832 return process_closing(bus, ret);
2835 assert_not_reached("Unknown state");
2838 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2839 return bus_process_internal(bus, false, 0, ret);
2842 #if 0 /// UNNEEDED by elogind
2843 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2844 return bus_process_internal(bus, true, priority, ret);
2848 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2849 struct pollfd p[2] = {};
2852 usec_t m = USEC_INFINITY;
2856 if (bus->state == BUS_CLOSING)
2859 if (!BUS_IS_OPEN(bus->state))
2862 e = sd_bus_get_events(bus);
2867 /* The caller really needs some more data, he doesn't
2868 * care about what's already read, or any timeouts
2869 * except its own. */
2873 /* The caller wants to process if there's something to
2874 * process, but doesn't care otherwise */
2876 r = sd_bus_get_timeout(bus, &until);
2881 nw = now(CLOCK_MONOTONIC);
2882 m = until > nw ? until - nw : 0;
2886 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2889 p[0].fd = bus->input_fd;
2890 if (bus->output_fd == bus->input_fd) {
2894 p[0].events = e & POLLIN;
2895 p[1].fd = bus->output_fd;
2896 p[1].events = e & POLLOUT;
2900 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2904 return r > 0 ? 1 : 0;
2907 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2909 assert_return(bus, -EINVAL);
2910 assert_return(!bus_pid_changed(bus), -ECHILD);
2912 if (bus->state == BUS_CLOSING)
2915 if (!BUS_IS_OPEN(bus->state))
2918 if (bus->rqueue_size > 0)
2921 return bus_poll(bus, false, timeout_usec);
2924 _public_ int sd_bus_flush(sd_bus *bus) {
2927 assert_return(bus, -EINVAL);
2928 assert_return(!bus_pid_changed(bus), -ECHILD);
2930 if (bus->state == BUS_CLOSING)
2933 if (!BUS_IS_OPEN(bus->state))
2936 r = bus_ensure_running(bus);
2940 if (bus->wqueue_size <= 0)
2944 r = dispatch_wqueue(bus);
2946 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2947 bus_enter_closing(bus);
2954 if (bus->wqueue_size <= 0)
2957 r = bus_poll(bus, false, (uint64_t) -1);
2963 #if 0 /// UNNEEDED by elogind
2964 _public_ int sd_bus_add_filter(
2967 sd_bus_message_handler_t callback,
2972 assert_return(bus, -EINVAL);
2973 assert_return(callback, -EINVAL);
2974 assert_return(!bus_pid_changed(bus), -ECHILD);
2976 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2980 s->filter_callback.callback = callback;
2982 bus->filter_callbacks_modified = true;
2983 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2992 _public_ int sd_bus_add_match(
2996 sd_bus_message_handler_t callback,
2999 struct bus_match_component *components = NULL;
3000 unsigned n_components = 0;
3001 sd_bus_slot *s = NULL;
3004 assert_return(bus, -EINVAL);
3005 assert_return(match, -EINVAL);
3006 assert_return(!bus_pid_changed(bus), -ECHILD);
3008 r = bus_match_parse(match, &components, &n_components);
3012 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3018 s->match_callback.callback = callback;
3019 s->match_callback.cookie = ++bus->match_cookie;
3021 if (bus->bus_client) {
3022 enum bus_match_scope scope;
3024 scope = bus_match_get_scope(components, n_components);
3026 /* Do not install server-side matches for matches
3027 * against the local service, interface or bus
3029 if (scope != BUS_MATCH_LOCAL) {
3031 if (!bus->is_kernel) {
3032 /* When this is not a kernel transport, we
3033 * store the original match string, so that we
3034 * can use it to remove the match again */
3036 s->match_callback.match_string = strdup(match);
3037 if (!s->match_callback.match_string) {
3043 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3047 s->match_added = true;
3051 bus->match_callbacks_modified = true;
3052 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3061 bus_match_parse_free(components, n_components);
3062 sd_bus_slot_unref(s);
3067 #if 0 /// UNNEEDED by elogind
3068 int bus_remove_match_by_string(
3071 sd_bus_message_handler_t callback,
3074 struct bus_match_component *components = NULL;
3075 unsigned n_components = 0;
3076 struct match_callback *c;
3079 assert_return(bus, -EINVAL);
3080 assert_return(match, -EINVAL);
3081 assert_return(!bus_pid_changed(bus), -ECHILD);
3083 r = bus_match_parse(match, &components, &n_components);
3087 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3091 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3094 bus_match_parse_free(components, n_components);
3100 bool bus_pid_changed(sd_bus *bus) {
3103 /* We don't support people creating a bus connection and
3104 * keeping it around over a fork(). Let's complain. */
3106 return bus->original_pid != getpid();
3109 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3110 sd_bus *bus = userdata;
3115 r = sd_bus_process(bus, NULL);
3122 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3123 sd_bus *bus = userdata;
3128 r = sd_bus_process(bus, NULL);
3135 static int prepare_callback(sd_event_source *s, void *userdata) {
3136 sd_bus *bus = userdata;
3143 e = sd_bus_get_events(bus);
3147 if (bus->output_fd != bus->input_fd) {
3149 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3153 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3157 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3162 r = sd_bus_get_timeout(bus, &until);
3168 j = sd_event_source_set_time(bus->time_event_source, until);
3173 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3180 static int quit_callback(sd_event_source *event, void *userdata) {
3181 sd_bus *bus = userdata;
3191 static int attach_io_events(sd_bus *bus) {
3196 if (bus->input_fd < 0)
3202 if (!bus->input_io_event_source) {
3203 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3207 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3211 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3215 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3217 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3222 if (bus->output_fd != bus->input_fd) {
3223 assert(bus->output_fd >= 0);
3225 if (!bus->output_io_event_source) {
3226 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3230 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3234 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3236 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3245 static void detach_io_events(sd_bus *bus) {
3248 if (bus->input_io_event_source) {
3249 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3250 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3253 if (bus->output_io_event_source) {
3254 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3255 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3259 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3262 assert_return(bus, -EINVAL);
3263 assert_return(!bus->event, -EBUSY);
3265 assert(!bus->input_io_event_source);
3266 assert(!bus->output_io_event_source);
3267 assert(!bus->time_event_source);
3270 bus->event = sd_event_ref(event);
3272 r = sd_event_default(&bus->event);
3277 bus->event_priority = priority;
3279 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3283 r = sd_event_source_set_priority(bus->time_event_source, priority);
3287 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3291 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3295 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3299 r = attach_io_events(bus);
3306 sd_bus_detach_event(bus);
3310 _public_ int sd_bus_detach_event(sd_bus *bus) {
3311 assert_return(bus, -EINVAL);
3316 detach_io_events(bus);
3318 if (bus->time_event_source) {
3319 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3320 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3323 if (bus->quit_event_source) {
3324 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3325 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3328 bus->event = sd_event_unref(bus->event);
3332 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3333 assert_return(bus, NULL);
3338 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3339 assert_return(bus, NULL);
3341 return bus->current_message;
3344 #if 0 /// UNNEEDED by elogind
3345 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3346 assert_return(bus, NULL);
3348 return bus->current_slot;
3352 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3353 assert_return(bus, NULL);
3355 return bus->current_handler;
3358 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3359 assert_return(bus, NULL);
3361 return bus->current_userdata;
3364 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3369 assert(default_bus);
3372 return !!*default_bus;
3375 *ret = sd_bus_ref(*default_bus);
3383 b->default_bus_ptr = default_bus;
3391 _public_ int sd_bus_default_system(sd_bus **ret) {
3392 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3396 _public_ int sd_bus_default_user(sd_bus **ret) {
3397 #if 0 /// elogind does not support user buses
3398 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3400 return sd_bus_default_system(ret);
3404 _public_ int sd_bus_default(sd_bus **ret) {
3408 /* Let's try our best to reuse another cached connection. If
3409 * the starter bus type is set, connect via our normal
3410 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3411 * we can share the connection with the user/system default
3414 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3416 if (streq(e, "system"))
3417 return sd_bus_default_system(ret);
3418 #if 0 /// elogind does not support systemd units
3419 else if (STR_IN_SET(e, "user", "session"))
3420 return sd_bus_default_user(ret);
3424 /* No type is specified, so we have not other option than to
3425 * use the starter address if it is set. */
3427 e = secure_getenv("DBUS_STARTER_ADDRESS");
3430 return bus_default(sd_bus_open, &default_starter_bus, ret);
3433 /* Finally, if nothing is set use the cached connection for
3434 * the right scope */
3436 #if 0 /// elogind does not support systemd units
3437 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3438 return sd_bus_default_user(ret);
3441 return sd_bus_default_system(ret);
3444 #if 0 /// UNNEEDED by elogind
3445 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3446 assert_return(b, -EINVAL);
3447 assert_return(tid, -EINVAL);
3448 assert_return(!bus_pid_changed(b), -ECHILD);
3456 return sd_event_get_tid(b->event, tid);
3461 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3462 _cleanup_free_ char *e = NULL;
3465 assert_return(object_path_is_valid(prefix), -EINVAL);
3466 assert_return(external_id, -EINVAL);
3467 assert_return(ret_path, -EINVAL);
3469 e = bus_label_escape(external_id);
3473 ret = strjoin(prefix, "/", e, NULL);
3481 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3485 assert_return(object_path_is_valid(path), -EINVAL);
3486 assert_return(object_path_is_valid(prefix), -EINVAL);
3487 assert_return(external_id, -EINVAL);
3489 e = object_path_startswith(path, prefix);
3491 *external_id = NULL;
3495 ret = bus_label_unescape(e);
3503 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3504 _cleanup_strv_free_ char **labels = NULL;
3505 char *path, *path_pos, **label_pos;
3506 const char *sep, *template_pos;
3511 assert_return(out, -EINVAL);
3512 assert_return(path_template, -EINVAL);
3514 path_length = strlen(path_template);
3516 va_start(list, path_template);
3517 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3521 arg = va_arg(list, const char *);
3527 label = bus_label_escape(arg);
3533 r = strv_consume(&labels, label);
3539 /* add label length, but account for the format character */
3540 path_length += strlen(label) - 1;
3544 path = malloc(path_length + 1);
3551 for (template_pos = path_template; *template_pos; ) {
3552 sep = strchrnul(template_pos, '%');
3553 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3557 path_pos = stpcpy(path_pos, *label_pos++);
3558 template_pos = sep + 1;
3566 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3567 _cleanup_strv_free_ char **labels = NULL;
3568 const char *template_pos, *path_pos;
3574 * This decodes an object-path based on a template argument. The
3575 * template consists of a verbatim path, optionally including special
3578 * - Each occurrence of '%' in the template matches an arbitrary
3579 * substring of a label in the given path. At most one such
3580 * directive is allowed per label. For each such directive, the
3581 * caller must provide an output parameter (char **) via va_arg. If
3582 * NULL is passed, the given label is verified, but not returned.
3583 * For each matched label, the *decoded* label is stored in the
3584 * passed output argument, and the caller is responsible to free
3585 * it. Note that the output arguments are only modified if the
3586 * actualy path matched the template. Otherwise, they're left
3589 * This function returns <0 on error, 0 if the path does not match the
3590 * template, 1 if it matched.
3593 assert_return(path, -EINVAL);
3594 assert_return(path_template, -EINVAL);
3598 for (template_pos = path_template; *template_pos; ) {
3603 /* verify everything until the next '%' matches verbatim */
3604 sep = strchrnul(template_pos, '%');
3605 length = sep - template_pos;
3606 if (strncmp(path_pos, template_pos, length))
3610 template_pos += length;
3615 /* We found the next '%' character. Everything up until here
3616 * matched. We now skip ahead to the end of this label and make
3617 * sure it matches the tail of the label in the path. Then we
3618 * decode the string in-between and save it for later use. */
3620 ++template_pos; /* skip over '%' */
3622 sep = strchrnul(template_pos, '/');
3623 length = sep - template_pos; /* length of suffix to match verbatim */
3625 /* verify the suffixes match */
3626 sep = strchrnul(path_pos, '/');
3627 if (sep - path_pos < (ssize_t)length ||
3628 strncmp(sep - length, template_pos, length))
3631 template_pos += length; /* skip over matched label */
3632 length = sep - path_pos - length; /* length of sub-label to decode */
3634 /* store unescaped label for later use */
3635 label = bus_label_unescape_n(path_pos, length);
3639 r = strv_consume(&labels, label);
3643 path_pos = sep; /* skip decoded label and suffix */
3646 /* end of template must match end of path */
3650 /* copy the labels over to the caller */
3651 va_start(list, path_template);
3652 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3655 arg = va_arg(list, char **);
3668 _public_ int sd_bus_try_close(sd_bus *bus) {
3671 assert_return(bus, -EINVAL);
3672 assert_return(!bus_pid_changed(bus), -ECHILD);
3674 if (!bus->is_kernel)
3677 if (!BUS_IS_OPEN(bus->state))
3680 if (bus->rqueue_size > 0)
3683 if (bus->wqueue_size > 0)
3686 r = bus_kernel_try_close(bus);
3694 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3695 assert_return(bus, -EINVAL);
3696 assert_return(description, -EINVAL);
3697 assert_return(bus->description, -ENXIO);
3698 assert_return(!bus_pid_changed(bus), -ECHILD);
3700 *description = bus->description;
3705 int bus_get_root_path(sd_bus *bus) {
3708 if (bus->cgroup_root)
3711 r = cg_get_root_path(&bus->cgroup_root);
3713 bus->cgroup_root = strdup("/");
3714 if (!bus->cgroup_root)
3723 #if 0 /// UNNEEDED by elogind
3724 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3727 assert_return(bus, -EINVAL);
3728 assert_return(scope, -EINVAL);
3729 assert_return(!bus_pid_changed(bus), -ECHILD);
3731 if (bus->is_kernel) {
3732 _cleanup_free_ char *n = NULL;
3735 r = bus_kernel_get_bus_name(bus, &n);
3739 if (streq(n, "0-system")) {
3744 dash = strchr(n, '-');
3745 if (streq_ptr(dash, "-user")) {
3756 if (bus->is_system) {
3764 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3766 assert_return(bus, -EINVAL);
3767 assert_return(address, -EINVAL);
3768 assert_return(!bus_pid_changed(bus), -ECHILD);
3771 *address = bus->address;
3778 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3779 assert_return(bus, -EINVAL);
3780 assert_return(mask, -EINVAL);
3781 assert_return(!bus_pid_changed(bus), -ECHILD);
3783 *mask = bus->creds_mask;
3787 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3788 assert_return(bus, -EINVAL);
3789 assert_return(!bus_pid_changed(bus), -ECHILD);
3791 return bus->bus_client;
3794 _public_ int sd_bus_is_server(sd_bus *bus) {
3795 assert_return(bus, -EINVAL);
3796 assert_return(!bus_pid_changed(bus), -ECHILD);
3798 return bus->is_server;
3801 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3802 assert_return(bus, -EINVAL);
3803 assert_return(!bus_pid_changed(bus), -ECHILD);
3805 return bus->anonymous_auth;
3808 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3809 assert_return(bus, -EINVAL);
3810 assert_return(!bus_pid_changed(bus), -ECHILD);
3812 return bus->trusted;
3815 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3816 assert_return(bus, -EINVAL);
3817 assert_return(!bus_pid_changed(bus), -ECHILD);
3819 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3822 static void flush_close(sd_bus *bus) {
3826 /* Flushes and closes the specified bus. We take a ref before,
3827 * to ensure the flushing does not cause the bus to be
3830 sd_bus_flush_close_unref(sd_bus_ref(bus));
3833 _public_ void sd_bus_default_flush_close(void) {
3834 flush_close(default_starter_bus);
3835 flush_close(default_user_bus);
3836 flush_close(default_system_bus);