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_(sd_bus_message_unrefp) 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) {
1503 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1508 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1514 i = REFCNT_DEC(bus->n_ref);
1522 #if 0 /// UNNEEDED by elogind
1523 _public_ int sd_bus_is_open(sd_bus *bus) {
1525 assert_return(bus, -EINVAL);
1526 assert_return(!bus_pid_changed(bus), -ECHILD);
1528 return BUS_IS_OPEN(bus->state);
1532 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1535 assert_return(bus, -EINVAL);
1536 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1537 assert_return(!bus_pid_changed(bus), -ECHILD);
1539 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1542 if (type == SD_BUS_TYPE_UNIX_FD) {
1543 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1546 r = bus_ensure_running(bus);
1550 return bus->can_fds;
1553 return bus_type_is_valid(type);
1556 #if 0 /// UNNEEDED by elogind
1557 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1560 assert_return(bus, -EINVAL);
1561 assert_return(id, -EINVAL);
1562 assert_return(!bus_pid_changed(bus), -ECHILD);
1564 r = bus_ensure_running(bus);
1568 *id = bus->server_id;
1573 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1578 /* If we copy the same message to multiple
1579 * destinations, avoid using the same cookie
1581 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1586 timeout = BUS_DEFAULT_TIMEOUT;
1588 return bus_message_seal(m, ++b->cookie, timeout);
1591 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1592 bool remarshal = false;
1596 /* wrong packet version */
1597 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1600 /* wrong packet endianness */
1601 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1604 /* TODO: kdbus-messages received from the kernel contain data which is
1605 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1606 * force remarshaling of the message. Technically, we could just
1607 * recreate the kdbus message, but that is non-trivial as other parts of
1608 * the message refer to m->kdbus already. This should be fixed! */
1609 if ((*m)->kdbus && (*m)->release_kdbus)
1612 return remarshal ? bus_message_remarshal(b, m) : 0;
1615 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1619 /* Fake some timestamps, if they were requested, and not
1620 * already initialized */
1621 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1622 if (m->realtime <= 0)
1623 m->realtime = now(CLOCK_REALTIME);
1625 if (m->monotonic <= 0)
1626 m->monotonic = now(CLOCK_MONOTONIC);
1629 /* The bus specification says the serial number cannot be 0,
1630 * hence let's fill something in for synthetic messages. Since
1631 * synthetic messages might have a fake sender and we don't
1632 * want to interfere with the real sender's serial numbers we
1633 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1634 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1635 * even though kdbus can do 64bit. */
1636 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1639 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1646 r = bus_kernel_write_message(bus, m, hint_sync_call);
1648 r = bus_socket_write_message(bus, m, idx);
1653 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1654 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1655 bus_message_type_to_string(m->header->type),
1656 strna(sd_bus_message_get_sender(m)),
1657 strna(sd_bus_message_get_destination(m)),
1658 strna(sd_bus_message_get_path(m)),
1659 strna(sd_bus_message_get_interface(m)),
1660 strna(sd_bus_message_get_member(m)),
1661 BUS_MESSAGE_COOKIE(m),
1663 strna(m->error.message));
1668 static int dispatch_wqueue(sd_bus *bus) {
1672 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1674 while (bus->wqueue_size > 0) {
1676 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1680 /* Didn't do anything this time */
1682 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1683 /* Fully written. Let's drop the entry from
1686 * This isn't particularly optimized, but
1687 * well, this is supposed to be our worst-case
1688 * buffer only, and the socket buffer is
1689 * supposed to be our primary buffer, and if
1690 * it got full, then all bets are off
1693 bus->wqueue_size --;
1694 sd_bus_message_unref(bus->wqueue[0]);
1695 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1705 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1709 return bus_kernel_read_message(bus, hint_priority, priority);
1711 return bus_socket_read_message(bus);
1714 int bus_rqueue_make_room(sd_bus *bus) {
1717 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1720 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1726 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1731 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1733 /* Note that the priority logic is only available on kdbus,
1734 * where the rqueue is unused. We check the rqueue here
1735 * anyway, because it's simple... */
1738 if (bus->rqueue_size > 0) {
1739 /* Dispatch a queued message */
1741 *m = bus->rqueue[0];
1742 bus->rqueue_size --;
1743 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1747 /* Try to read a new message */
1748 r = bus_read_message(bus, hint_priority, priority);
1758 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1759 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1762 assert_return(m, -EINVAL);
1767 assert_return(!bus_pid_changed(bus), -ECHILD);
1768 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1770 if (!BUS_IS_OPEN(bus->state))
1774 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1781 /* If the cookie number isn't kept, then we know that no reply
1783 if (!cookie && !m->sealed)
1784 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1786 r = bus_seal_message(bus, m, 0);
1790 /* Remarshall if we have to. This will possibly unref the
1791 * message and place a replacement in m */
1792 r = bus_remarshal_message(bus, &m);
1796 /* If this is a reply and no reply was requested, then let's
1797 * suppress this, if we can */
1801 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1804 r = bus_write_message(bus, m, hint_sync_call, &idx);
1806 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1807 bus_enter_closing(bus);
1814 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1815 /* Wasn't fully written. So let's remember how
1816 * much was written. Note that the first entry
1817 * of the wqueue array is always allocated so
1818 * that we always can remember how much was
1820 bus->wqueue[0] = sd_bus_message_ref(m);
1821 bus->wqueue_size = 1;
1826 /* Just append it to the queue. */
1828 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1831 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1834 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1839 *cookie = BUS_MESSAGE_COOKIE(m);
1844 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1845 return bus_send_internal(bus, m, cookie, false);
1848 #if 0 /// 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_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1910 _cleanup_(sd_bus_slot_unrefp) 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_(sd_bus_message_unrefp) 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 #if 0 /// UNNEEDED by elogind
2160 _public_ int sd_bus_get_fd(sd_bus *bus) {
2162 assert_return(bus, -EINVAL);
2163 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2164 assert_return(!bus_pid_changed(bus), -ECHILD);
2166 return bus->input_fd;
2170 _public_ int sd_bus_get_events(sd_bus *bus) {
2173 assert_return(bus, -EINVAL);
2174 assert_return(!bus_pid_changed(bus), -ECHILD);
2176 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2179 if (bus->state == BUS_OPENING)
2181 else if (bus->state == BUS_AUTHENTICATING) {
2183 if (bus_socket_auth_needs_write(bus))
2188 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2189 if (bus->rqueue_size <= 0)
2191 if (bus->wqueue_size > 0)
2198 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2199 struct reply_callback *c;
2201 assert_return(bus, -EINVAL);
2202 assert_return(timeout_usec, -EINVAL);
2203 assert_return(!bus_pid_changed(bus), -ECHILD);
2205 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2208 if (bus->track_queue) {
2213 if (bus->state == BUS_CLOSING) {
2218 if (bus->state == BUS_AUTHENTICATING) {
2219 *timeout_usec = bus->auth_timeout;
2223 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2224 *timeout_usec = (uint64_t) -1;
2228 if (bus->rqueue_size > 0) {
2233 c = prioq_peek(bus->reply_callbacks_prioq);
2235 *timeout_usec = (uint64_t) -1;
2239 if (c->timeout == 0) {
2240 *timeout_usec = (uint64_t) -1;
2244 *timeout_usec = c->timeout;
2248 static int process_timeout(sd_bus *bus) {
2249 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2250 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2251 struct reply_callback *c;
2258 c = prioq_peek(bus->reply_callbacks_prioq);
2262 n = now(CLOCK_MONOTONIC);
2266 r = bus_message_new_synthetic_error(
2269 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2274 r = bus_seal_synthetic_message(bus, m);
2278 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2281 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2284 slot = container_of(c, sd_bus_slot, reply_callback);
2286 bus->iteration_counter ++;
2288 bus->current_message = m;
2289 bus->current_slot = sd_bus_slot_ref(slot);
2290 bus->current_handler = c->callback;
2291 bus->current_userdata = slot->userdata;
2292 r = c->callback(m, slot->userdata, &error_buffer);
2293 bus->current_userdata = NULL;
2294 bus->current_handler = NULL;
2295 bus->current_slot = NULL;
2296 bus->current_message = NULL;
2298 if (slot->floating) {
2299 bus_slot_disconnect(slot);
2300 sd_bus_slot_unref(slot);
2303 sd_bus_slot_unref(slot);
2305 return bus_maybe_reply_error(m, r, &error_buffer);
2308 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2312 if (bus->state != BUS_HELLO)
2315 /* Let's make sure the first message on the bus is the HELLO
2316 * reply. But note that we don't actually parse the message
2317 * here (we leave that to the usual handling), we just verify
2318 * we don't let any earlier msg through. */
2320 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2321 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2324 if (m->reply_cookie != 1)
2330 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2331 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2332 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2333 struct reply_callback *c;
2340 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2341 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2344 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2347 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2350 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2356 slot = container_of(c, sd_bus_slot, reply_callback);
2358 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2360 /* If the reply contained a file descriptor which we
2361 * didn't want we pass an error instead. */
2363 r = bus_message_new_synthetic_error(
2366 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2371 /* Copy over original timestamp */
2372 synthetic_reply->realtime = m->realtime;
2373 synthetic_reply->monotonic = m->monotonic;
2374 synthetic_reply->seqnum = m->seqnum;
2376 r = bus_seal_synthetic_message(bus, synthetic_reply);
2380 m = synthetic_reply;
2382 r = sd_bus_message_rewind(m, true);
2387 if (c->timeout != 0) {
2388 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2392 bus->current_slot = sd_bus_slot_ref(slot);
2393 bus->current_handler = c->callback;
2394 bus->current_userdata = slot->userdata;
2395 r = c->callback(m, slot->userdata, &error_buffer);
2396 bus->current_userdata = NULL;
2397 bus->current_handler = NULL;
2398 bus->current_slot = NULL;
2400 if (slot->floating) {
2401 bus_slot_disconnect(slot);
2402 sd_bus_slot_unref(slot);
2405 sd_bus_slot_unref(slot);
2407 return bus_maybe_reply_error(m, r, &error_buffer);
2410 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2411 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2412 struct filter_callback *l;
2419 bus->filter_callbacks_modified = false;
2421 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2424 if (bus->filter_callbacks_modified)
2427 /* Don't run this more than once per iteration */
2428 if (l->last_iteration == bus->iteration_counter)
2431 l->last_iteration = bus->iteration_counter;
2433 r = sd_bus_message_rewind(m, true);
2437 slot = container_of(l, sd_bus_slot, filter_callback);
2439 bus->current_slot = sd_bus_slot_ref(slot);
2440 bus->current_handler = l->callback;
2441 bus->current_userdata = slot->userdata;
2442 r = l->callback(m, slot->userdata, &error_buffer);
2443 bus->current_userdata = NULL;
2444 bus->current_handler = NULL;
2445 bus->current_slot = sd_bus_slot_unref(slot);
2447 r = bus_maybe_reply_error(m, r, &error_buffer);
2453 } while (bus->filter_callbacks_modified);
2458 static int process_match(sd_bus *bus, sd_bus_message *m) {
2465 bus->match_callbacks_modified = false;
2467 r = bus_match_run(bus, &bus->match_callbacks, m);
2471 } while (bus->match_callbacks_modified);
2476 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2477 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2483 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2486 if (bus->manual_peer_interface)
2489 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2492 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2495 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2498 if (streq_ptr(m->member, "Ping"))
2499 r = sd_bus_message_new_method_return(m, &reply);
2500 else if (streq_ptr(m->member, "GetMachineId")) {
2504 r = sd_id128_get_machine(&id);
2508 r = sd_bus_message_new_method_return(m, &reply);
2512 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2514 r = sd_bus_message_new_method_errorf(
2516 SD_BUS_ERROR_UNKNOWN_METHOD,
2517 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2523 r = sd_bus_send(bus, reply, NULL);
2530 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2534 /* If we got a message with a file descriptor which we didn't
2535 * want to accept, then let's drop it. How can this even
2536 * happen? For example, when the kernel queues a message into
2537 * an activatable names's queue which allows fds, and then is
2538 * delivered to us later even though we ourselves did not
2541 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2547 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2550 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2551 return 1; /* just eat it up */
2553 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2556 static int process_message(sd_bus *bus, sd_bus_message *m) {
2562 bus->current_message = m;
2563 bus->iteration_counter++;
2565 log_debug_bus_message(m);
2567 r = process_hello(bus, m);
2571 r = process_reply(bus, m);
2575 r = process_fd_check(bus, m);
2579 r = process_filter(bus, m);
2583 r = process_match(bus, m);
2587 r = process_builtin(bus, m);
2591 r = bus_process_object(bus, m);
2594 bus->current_message = NULL;
2598 static int dispatch_track(sd_bus *bus) {
2601 if (!bus->track_queue)
2604 bus_track_dispatch(bus->track_queue);
2608 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2609 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2613 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2615 r = process_timeout(bus);
2619 r = dispatch_wqueue(bus);
2623 r = dispatch_track(bus);
2627 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2633 r = process_message(bus, m);
2638 r = sd_bus_message_rewind(m, true);
2647 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2649 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2650 strna(sd_bus_message_get_sender(m)),
2651 strna(sd_bus_message_get_path(m)),
2652 strna(sd_bus_message_get_interface(m)),
2653 strna(sd_bus_message_get_member(m)));
2655 r = sd_bus_reply_method_errorf(
2657 SD_BUS_ERROR_UNKNOWN_OBJECT,
2658 "Unknown object '%s'.", m->path);
2672 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2673 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2674 struct reply_callback *c;
2678 assert(bus->state == BUS_CLOSING);
2680 c = ordered_hashmap_first(bus->reply_callbacks);
2682 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2685 /* First, fail all outstanding method calls */
2686 r = bus_message_new_synthetic_error(
2689 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2694 r = bus_seal_synthetic_message(bus, m);
2698 if (c->timeout != 0) {
2699 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2703 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2706 slot = container_of(c, sd_bus_slot, reply_callback);
2708 bus->iteration_counter++;
2710 bus->current_message = m;
2711 bus->current_slot = sd_bus_slot_ref(slot);
2712 bus->current_handler = c->callback;
2713 bus->current_userdata = slot->userdata;
2714 r = c->callback(m, slot->userdata, &error_buffer);
2715 bus->current_userdata = NULL;
2716 bus->current_handler = NULL;
2717 bus->current_slot = NULL;
2718 bus->current_message = NULL;
2720 if (slot->floating) {
2721 bus_slot_disconnect(slot);
2722 sd_bus_slot_unref(slot);
2725 sd_bus_slot_unref(slot);
2727 return bus_maybe_reply_error(m, r, &error_buffer);
2730 /* Then, synthesize a Disconnected message */
2731 r = sd_bus_message_new_signal(
2734 "/org/freedesktop/DBus/Local",
2735 "org.freedesktop.DBus.Local",
2740 bus_message_set_sender_local(bus, m);
2742 r = bus_seal_synthetic_message(bus, m);
2748 bus->current_message = m;
2749 bus->iteration_counter++;
2751 r = process_filter(bus, m);
2755 r = process_match(bus, m);
2767 bus->current_message = NULL;
2772 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2773 BUS_DONT_DESTROY(bus);
2776 /* Returns 0 when we didn't do anything. This should cause the
2777 * caller to invoke sd_bus_wait() before returning the next
2778 * time. Returns > 0 when we did something, which possibly
2779 * means *ret is filled in with an unprocessed message. */
2781 assert_return(bus, -EINVAL);
2782 assert_return(!bus_pid_changed(bus), -ECHILD);
2784 /* We don't allow recursively invoking sd_bus_process(). */
2785 assert_return(!bus->current_message, -EBUSY);
2786 assert(!bus->current_slot);
2788 switch (bus->state) {
2797 r = bus_socket_process_opening(bus);
2798 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2799 bus_enter_closing(bus);
2807 case BUS_AUTHENTICATING:
2808 r = bus_socket_process_authenticating(bus);
2809 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2810 bus_enter_closing(bus);
2822 r = process_running(bus, hint_priority, priority, ret);
2823 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2824 bus_enter_closing(bus);
2834 return process_closing(bus, ret);
2837 assert_not_reached("Unknown state");
2840 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2841 return bus_process_internal(bus, false, 0, ret);
2844 #if 0 /// UNNEEDED by elogind
2845 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2846 return bus_process_internal(bus, true, priority, ret);
2850 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2851 struct pollfd p[2] = {};
2854 usec_t m = USEC_INFINITY;
2858 if (bus->state == BUS_CLOSING)
2861 if (!BUS_IS_OPEN(bus->state))
2864 e = sd_bus_get_events(bus);
2869 /* The caller really needs some more data, he doesn't
2870 * care about what's already read, or any timeouts
2871 * except its own. */
2875 /* The caller wants to process if there's something to
2876 * process, but doesn't care otherwise */
2878 r = sd_bus_get_timeout(bus, &until);
2883 nw = now(CLOCK_MONOTONIC);
2884 m = until > nw ? until - nw : 0;
2888 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2891 p[0].fd = bus->input_fd;
2892 if (bus->output_fd == bus->input_fd) {
2896 p[0].events = e & POLLIN;
2897 p[1].fd = bus->output_fd;
2898 p[1].events = e & POLLOUT;
2902 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2906 return r > 0 ? 1 : 0;
2909 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2911 assert_return(bus, -EINVAL);
2912 assert_return(!bus_pid_changed(bus), -ECHILD);
2914 if (bus->state == BUS_CLOSING)
2917 if (!BUS_IS_OPEN(bus->state))
2920 if (bus->rqueue_size > 0)
2923 return bus_poll(bus, false, timeout_usec);
2926 _public_ int sd_bus_flush(sd_bus *bus) {
2929 assert_return(bus, -EINVAL);
2930 assert_return(!bus_pid_changed(bus), -ECHILD);
2932 if (bus->state == BUS_CLOSING)
2935 if (!BUS_IS_OPEN(bus->state))
2938 r = bus_ensure_running(bus);
2942 if (bus->wqueue_size <= 0)
2946 r = dispatch_wqueue(bus);
2948 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2949 bus_enter_closing(bus);
2956 if (bus->wqueue_size <= 0)
2959 r = bus_poll(bus, false, (uint64_t) -1);
2965 #if 0 /// UNNEEDED by elogind
2966 _public_ int sd_bus_add_filter(
2969 sd_bus_message_handler_t callback,
2974 assert_return(bus, -EINVAL);
2975 assert_return(callback, -EINVAL);
2976 assert_return(!bus_pid_changed(bus), -ECHILD);
2978 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2982 s->filter_callback.callback = callback;
2984 bus->filter_callbacks_modified = true;
2985 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2994 _public_ int sd_bus_add_match(
2998 sd_bus_message_handler_t callback,
3001 struct bus_match_component *components = NULL;
3002 unsigned n_components = 0;
3003 sd_bus_slot *s = NULL;
3006 assert_return(bus, -EINVAL);
3007 assert_return(match, -EINVAL);
3008 assert_return(!bus_pid_changed(bus), -ECHILD);
3010 r = bus_match_parse(match, &components, &n_components);
3014 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3020 s->match_callback.callback = callback;
3021 s->match_callback.cookie = ++bus->match_cookie;
3023 if (bus->bus_client) {
3024 enum bus_match_scope scope;
3026 scope = bus_match_get_scope(components, n_components);
3028 /* Do not install server-side matches for matches
3029 * against the local service, interface or bus
3031 if (scope != BUS_MATCH_LOCAL) {
3033 if (!bus->is_kernel) {
3034 /* When this is not a kernel transport, we
3035 * store the original match string, so that we
3036 * can use it to remove the match again */
3038 s->match_callback.match_string = strdup(match);
3039 if (!s->match_callback.match_string) {
3045 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3049 s->match_added = true;
3053 bus->match_callbacks_modified = true;
3054 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3063 bus_match_parse_free(components, n_components);
3064 sd_bus_slot_unref(s);
3069 #if 0 /// UNNEEDED by elogind
3070 int bus_remove_match_by_string(
3073 sd_bus_message_handler_t callback,
3076 struct bus_match_component *components = NULL;
3077 unsigned n_components = 0;
3078 struct match_callback *c;
3081 assert_return(bus, -EINVAL);
3082 assert_return(match, -EINVAL);
3083 assert_return(!bus_pid_changed(bus), -ECHILD);
3085 r = bus_match_parse(match, &components, &n_components);
3089 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3093 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3096 bus_match_parse_free(components, n_components);
3102 bool bus_pid_changed(sd_bus *bus) {
3105 /* We don't support people creating a bus connection and
3106 * keeping it around over a fork(). Let's complain. */
3108 return bus->original_pid != getpid();
3111 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3112 sd_bus *bus = userdata;
3117 r = sd_bus_process(bus, NULL);
3124 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3125 sd_bus *bus = userdata;
3130 r = sd_bus_process(bus, NULL);
3137 static int prepare_callback(sd_event_source *s, void *userdata) {
3138 sd_bus *bus = userdata;
3145 e = sd_bus_get_events(bus);
3149 if (bus->output_fd != bus->input_fd) {
3151 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3155 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3159 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3164 r = sd_bus_get_timeout(bus, &until);
3170 j = sd_event_source_set_time(bus->time_event_source, until);
3175 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3182 static int quit_callback(sd_event_source *event, void *userdata) {
3183 sd_bus *bus = userdata;
3193 static int attach_io_events(sd_bus *bus) {
3198 if (bus->input_fd < 0)
3204 if (!bus->input_io_event_source) {
3205 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3209 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3213 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3217 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3219 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3224 if (bus->output_fd != bus->input_fd) {
3225 assert(bus->output_fd >= 0);
3227 if (!bus->output_io_event_source) {
3228 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3232 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3236 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3238 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3247 static void detach_io_events(sd_bus *bus) {
3250 if (bus->input_io_event_source) {
3251 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3252 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3255 if (bus->output_io_event_source) {
3256 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3257 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3261 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3264 assert_return(bus, -EINVAL);
3265 assert_return(!bus->event, -EBUSY);
3267 assert(!bus->input_io_event_source);
3268 assert(!bus->output_io_event_source);
3269 assert(!bus->time_event_source);
3272 bus->event = sd_event_ref(event);
3274 r = sd_event_default(&bus->event);
3279 bus->event_priority = priority;
3281 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3285 r = sd_event_source_set_priority(bus->time_event_source, priority);
3289 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3293 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3297 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3301 r = attach_io_events(bus);
3308 sd_bus_detach_event(bus);
3312 _public_ int sd_bus_detach_event(sd_bus *bus) {
3313 assert_return(bus, -EINVAL);
3318 detach_io_events(bus);
3320 if (bus->time_event_source) {
3321 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3322 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3325 if (bus->quit_event_source) {
3326 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3327 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3330 bus->event = sd_event_unref(bus->event);
3334 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3335 assert_return(bus, NULL);
3340 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3341 assert_return(bus, NULL);
3343 return bus->current_message;
3346 #if 0 /// UNNEEDED by elogind
3347 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3348 assert_return(bus, NULL);
3350 return bus->current_slot;
3354 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3355 assert_return(bus, NULL);
3357 return bus->current_handler;
3360 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3361 assert_return(bus, NULL);
3363 return bus->current_userdata;
3366 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3371 assert(default_bus);
3374 return !!*default_bus;
3377 *ret = sd_bus_ref(*default_bus);
3385 b->default_bus_ptr = default_bus;
3393 _public_ int sd_bus_default_system(sd_bus **ret) {
3394 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3398 _public_ int sd_bus_default_user(sd_bus **ret) {
3399 #if 0 /// elogind does not support user buses
3400 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3402 return sd_bus_default_system(ret);
3406 _public_ int sd_bus_default(sd_bus **ret) {
3410 /* Let's try our best to reuse another cached connection. If
3411 * the starter bus type is set, connect via our normal
3412 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3413 * we can share the connection with the user/system default
3416 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3418 if (streq(e, "system"))
3419 return sd_bus_default_system(ret);
3420 #if 0 /// elogind does not support systemd units
3421 else if (STR_IN_SET(e, "user", "session"))
3422 return sd_bus_default_user(ret);
3426 /* No type is specified, so we have not other option than to
3427 * use the starter address if it is set. */
3429 e = secure_getenv("DBUS_STARTER_ADDRESS");
3432 return bus_default(sd_bus_open, &default_starter_bus, ret);
3435 /* Finally, if nothing is set use the cached connection for
3436 * the right scope */
3438 #if 0 /// elogind does not support systemd units
3439 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3440 return sd_bus_default_user(ret);
3443 return sd_bus_default_system(ret);
3446 #if 0 /// UNNEEDED by elogind
3447 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3448 assert_return(b, -EINVAL);
3449 assert_return(tid, -EINVAL);
3450 assert_return(!bus_pid_changed(b), -ECHILD);
3458 return sd_event_get_tid(b->event, tid);
3463 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3464 _cleanup_free_ char *e = NULL;
3467 assert_return(object_path_is_valid(prefix), -EINVAL);
3468 assert_return(external_id, -EINVAL);
3469 assert_return(ret_path, -EINVAL);
3471 e = bus_label_escape(external_id);
3475 ret = strjoin(prefix, "/", e, NULL);
3483 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3487 assert_return(object_path_is_valid(path), -EINVAL);
3488 assert_return(object_path_is_valid(prefix), -EINVAL);
3489 assert_return(external_id, -EINVAL);
3491 e = object_path_startswith(path, prefix);
3493 *external_id = NULL;
3497 ret = bus_label_unescape(e);
3505 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3506 _cleanup_strv_free_ char **labels = NULL;
3507 char *path, *path_pos, **label_pos;
3508 const char *sep, *template_pos;
3513 assert_return(out, -EINVAL);
3514 assert_return(path_template, -EINVAL);
3516 path_length = strlen(path_template);
3518 va_start(list, path_template);
3519 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3523 arg = va_arg(list, const char *);
3529 label = bus_label_escape(arg);
3535 r = strv_consume(&labels, label);
3541 /* add label length, but account for the format character */
3542 path_length += strlen(label) - 1;
3546 path = malloc(path_length + 1);
3553 for (template_pos = path_template; *template_pos; ) {
3554 sep = strchrnul(template_pos, '%');
3555 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3559 path_pos = stpcpy(path_pos, *label_pos++);
3560 template_pos = sep + 1;
3568 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3569 _cleanup_strv_free_ char **labels = NULL;
3570 const char *template_pos, *path_pos;
3576 * This decodes an object-path based on a template argument. The
3577 * template consists of a verbatim path, optionally including special
3580 * - Each occurrence of '%' in the template matches an arbitrary
3581 * substring of a label in the given path. At most one such
3582 * directive is allowed per label. For each such directive, the
3583 * caller must provide an output parameter (char **) via va_arg. If
3584 * NULL is passed, the given label is verified, but not returned.
3585 * For each matched label, the *decoded* label is stored in the
3586 * passed output argument, and the caller is responsible to free
3587 * it. Note that the output arguments are only modified if the
3588 * actualy path matched the template. Otherwise, they're left
3591 * This function returns <0 on error, 0 if the path does not match the
3592 * template, 1 if it matched.
3595 assert_return(path, -EINVAL);
3596 assert_return(path_template, -EINVAL);
3600 for (template_pos = path_template; *template_pos; ) {
3605 /* verify everything until the next '%' matches verbatim */
3606 sep = strchrnul(template_pos, '%');
3607 length = sep - template_pos;
3608 if (strncmp(path_pos, template_pos, length))
3612 template_pos += length;
3617 /* We found the next '%' character. Everything up until here
3618 * matched. We now skip ahead to the end of this label and make
3619 * sure it matches the tail of the label in the path. Then we
3620 * decode the string in-between and save it for later use. */
3622 ++template_pos; /* skip over '%' */
3624 sep = strchrnul(template_pos, '/');
3625 length = sep - template_pos; /* length of suffix to match verbatim */
3627 /* verify the suffixes match */
3628 sep = strchrnul(path_pos, '/');
3629 if (sep - path_pos < (ssize_t)length ||
3630 strncmp(sep - length, template_pos, length))
3633 template_pos += length; /* skip over matched label */
3634 length = sep - path_pos - length; /* length of sub-label to decode */
3636 /* store unescaped label for later use */
3637 label = bus_label_unescape_n(path_pos, length);
3641 r = strv_consume(&labels, label);
3645 path_pos = sep; /* skip decoded label and suffix */
3648 /* end of template must match end of path */
3652 /* copy the labels over to the caller */
3653 va_start(list, path_template);
3654 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3657 arg = va_arg(list, char **);
3670 _public_ int sd_bus_try_close(sd_bus *bus) {
3673 assert_return(bus, -EINVAL);
3674 assert_return(!bus_pid_changed(bus), -ECHILD);
3676 if (!bus->is_kernel)
3679 if (!BUS_IS_OPEN(bus->state))
3682 if (bus->rqueue_size > 0)
3685 if (bus->wqueue_size > 0)
3688 r = bus_kernel_try_close(bus);
3696 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3697 assert_return(bus, -EINVAL);
3698 assert_return(description, -EINVAL);
3699 assert_return(bus->description, -ENXIO);
3700 assert_return(!bus_pid_changed(bus), -ECHILD);
3702 *description = bus->description;
3707 int bus_get_root_path(sd_bus *bus) {
3710 if (bus->cgroup_root)
3713 r = cg_get_root_path(&bus->cgroup_root);
3715 bus->cgroup_root = strdup("/");
3716 if (!bus->cgroup_root)
3725 #if 0 /// UNNEEDED by elogind
3726 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3729 assert_return(bus, -EINVAL);
3730 assert_return(scope, -EINVAL);
3731 assert_return(!bus_pid_changed(bus), -ECHILD);
3733 if (bus->is_kernel) {
3734 _cleanup_free_ char *n = NULL;
3737 r = bus_kernel_get_bus_name(bus, &n);
3741 if (streq(n, "0-system")) {
3746 dash = strchr(n, '-');
3747 if (streq_ptr(dash, "-user")) {
3758 if (bus->is_system) {
3766 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3768 assert_return(bus, -EINVAL);
3769 assert_return(address, -EINVAL);
3770 assert_return(!bus_pid_changed(bus), -ECHILD);
3773 *address = bus->address;
3780 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3781 assert_return(bus, -EINVAL);
3782 assert_return(mask, -EINVAL);
3783 assert_return(!bus_pid_changed(bus), -ECHILD);
3785 *mask = bus->creds_mask;
3789 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3790 assert_return(bus, -EINVAL);
3791 assert_return(!bus_pid_changed(bus), -ECHILD);
3793 return bus->bus_client;
3796 _public_ int sd_bus_is_server(sd_bus *bus) {
3797 assert_return(bus, -EINVAL);
3798 assert_return(!bus_pid_changed(bus), -ECHILD);
3800 return bus->is_server;
3803 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3804 assert_return(bus, -EINVAL);
3805 assert_return(!bus_pid_changed(bus), -ECHILD);
3807 return bus->anonymous_auth;
3810 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3811 assert_return(bus, -EINVAL);
3812 assert_return(!bus_pid_changed(bus), -ECHILD);
3814 return bus->trusted;
3817 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3818 assert_return(bus, -EINVAL);
3819 assert_return(!bus_pid_changed(bus), -ECHILD);
3821 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3824 static void flush_close(sd_bus *bus) {
3828 /* Flushes and closes the specified bus. We take a ref before,
3829 * to ensure the flushing does not cause the bus to be
3832 sd_bus_flush_close_unref(sd_bus_ref(bus));
3835 _public_ void sd_bus_default_flush_close(void) {
3836 flush_close(default_starter_bus);
3837 flush_close(default_user_bus);
3838 flush_close(default_system_bus);