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 /// elogind does not support systemd units
1169 else if (STR_IN_SET(e, "session", "user"))
1170 return sd_bus_open_user(ret);
1174 e = secure_getenv("DBUS_STARTER_ADDRESS");
1176 /// elogind does not support systemd units
1178 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1179 return sd_bus_open_user(ret);
1182 return sd_bus_open_system(ret);
1189 r = sd_bus_set_address(b, e);
1193 b->bus_client = true;
1195 /* We don't know whether the bus is trusted or not, so better
1196 * be safe, and authenticate everything */
1198 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1199 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1201 r = sd_bus_start(b);
1213 int bus_set_address_system(sd_bus *b) {
1217 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1219 return sd_bus_set_address(b, e);
1221 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1224 _public_ int sd_bus_open_system(sd_bus **ret) {
1228 assert_return(ret, -EINVAL);
1234 r = bus_set_address_system(b);
1238 b->bus_client = true;
1239 b->is_system = true;
1241 /* Let's do per-method access control on the system bus. We
1242 * need the caller's UID and capability set for that. */
1244 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1245 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1247 r = sd_bus_start(b);
1259 /// elogind can not open/use a user bus
1261 int bus_set_address_user(sd_bus *b) {
1268 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1270 return sd_bus_set_address(b, e);
1272 r = cg_pid_get_owner_uid(0, &uid);
1276 e = secure_getenv("XDG_RUNTIME_DIR");
1278 _cleanup_free_ char *ee = NULL;
1280 ee = bus_address_escape(e);
1284 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1286 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1295 _public_ int sd_bus_open_user(sd_bus **ret) {
1296 /// elogind does not support user buses
1301 assert_return(ret, -EINVAL);
1307 r = bus_set_address_user(b);
1311 b->bus_client = true;
1314 /* We don't do any per-method access control on the user
1318 r = sd_bus_start(b);
1329 return sd_bus_open_system(ret);
1333 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1334 _cleanup_free_ char *e = NULL;
1335 char *m = NULL, *c = NULL;
1340 /* Let's see if we shall enter some container */
1341 m = strchr(host, ':');
1345 /* Let's make sure this is not a port of some kind,
1346 * and is a valid machine name. */
1347 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1350 /* Cut out the host part */
1351 t = strndupa(host, m - host - 1);
1352 e = bus_address_escape(t);
1356 c = strjoina(",argv4=--machine=", m);
1361 e = bus_address_escape(host);
1366 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1373 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1377 assert_return(host, -EINVAL);
1378 assert_return(ret, -EINVAL);
1380 r = sd_bus_new(&bus);
1384 r = bus_set_address_system_remote(bus, host);
1388 bus->bus_client = true;
1389 bus->trusted = false;
1390 bus->is_system = true;
1392 r = sd_bus_start(bus);
1404 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1405 _cleanup_free_ char *e = NULL;
1410 e = bus_address_escape(machine);
1414 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1421 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1425 assert_return(machine, -EINVAL);
1426 assert_return(ret, -EINVAL);
1427 assert_return(machine_name_is_valid(machine), -EINVAL);
1429 r = sd_bus_new(&bus);
1433 r = bus_set_address_system_machine(bus, machine);
1437 bus->bus_client = true;
1438 bus->trusted = false;
1439 bus->is_system = true;
1441 r = sd_bus_start(bus);
1453 _public_ void sd_bus_close(sd_bus *bus) {
1457 if (bus->state == BUS_CLOSED)
1459 if (bus_pid_changed(bus))
1462 bus->state = BUS_CLOSED;
1464 sd_bus_detach_event(bus);
1466 /* Drop all queued messages so that they drop references to
1467 * the bus object and the bus may be freed */
1468 bus_reset_queues(bus);
1470 if (!bus->is_kernel)
1473 /* We'll leave the fd open in case this is a kernel bus, since
1474 * there might still be memblocks around that reference this
1475 * bus, and they might need to invoke the KDBUS_CMD_FREE
1476 * ioctl on the fd when they are freed. */
1479 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1487 return sd_bus_unref(bus);
1490 static void bus_enter_closing(sd_bus *bus) {
1493 if (bus->state != BUS_OPENING &&
1494 bus->state != BUS_AUTHENTICATING &&
1495 bus->state != BUS_HELLO &&
1496 bus->state != BUS_RUNNING)
1499 bus->state = BUS_CLOSING;
1502 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1503 assert_return(bus, NULL);
1505 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1510 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1516 i = REFCNT_DEC(bus->n_ref);
1524 #if 0 /// UNNEEDED by elogind
1525 _public_ int sd_bus_is_open(sd_bus *bus) {
1527 assert_return(bus, -EINVAL);
1528 assert_return(!bus_pid_changed(bus), -ECHILD);
1530 return BUS_IS_OPEN(bus->state);
1534 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1537 assert_return(bus, -EINVAL);
1538 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1539 assert_return(!bus_pid_changed(bus), -ECHILD);
1541 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1544 if (type == SD_BUS_TYPE_UNIX_FD) {
1545 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1548 r = bus_ensure_running(bus);
1552 return bus->can_fds;
1555 return bus_type_is_valid(type);
1558 #if 0 /// UNNEEDED by elogind
1559 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1562 assert_return(bus, -EINVAL);
1563 assert_return(id, -EINVAL);
1564 assert_return(!bus_pid_changed(bus), -ECHILD);
1566 r = bus_ensure_running(bus);
1570 *id = bus->server_id;
1575 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1580 /* If we copy the same message to multiple
1581 * destinations, avoid using the same cookie
1583 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1588 timeout = BUS_DEFAULT_TIMEOUT;
1590 return bus_message_seal(m, ++b->cookie, timeout);
1593 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1594 bool remarshal = false;
1598 /* wrong packet version */
1599 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1602 /* wrong packet endianness */
1603 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1606 /* TODO: kdbus-messages received from the kernel contain data which is
1607 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1608 * force remarshaling of the message. Technically, we could just
1609 * recreate the kdbus message, but that is non-trivial as other parts of
1610 * the message refer to m->kdbus already. This should be fixed! */
1611 if ((*m)->kdbus && (*m)->release_kdbus)
1614 return remarshal ? bus_message_remarshal(b, m) : 0;
1617 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1621 /* Fake some timestamps, if they were requested, and not
1622 * already initialized */
1623 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1624 if (m->realtime <= 0)
1625 m->realtime = now(CLOCK_REALTIME);
1627 if (m->monotonic <= 0)
1628 m->monotonic = now(CLOCK_MONOTONIC);
1631 /* The bus specification says the serial number cannot be 0,
1632 * hence let's fill something in for synthetic messages. Since
1633 * synthetic messages might have a fake sender and we don't
1634 * want to interfere with the real sender's serial numbers we
1635 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1636 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1637 * even though kdbus can do 64bit. */
1638 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1641 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1648 r = bus_kernel_write_message(bus, m, hint_sync_call);
1650 r = bus_socket_write_message(bus, m, idx);
1655 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1656 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1657 bus_message_type_to_string(m->header->type),
1658 strna(sd_bus_message_get_sender(m)),
1659 strna(sd_bus_message_get_destination(m)),
1660 strna(sd_bus_message_get_path(m)),
1661 strna(sd_bus_message_get_interface(m)),
1662 strna(sd_bus_message_get_member(m)),
1663 BUS_MESSAGE_COOKIE(m),
1665 strna(m->error.message));
1670 static int dispatch_wqueue(sd_bus *bus) {
1674 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1676 while (bus->wqueue_size > 0) {
1678 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1682 /* Didn't do anything this time */
1684 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1685 /* Fully written. Let's drop the entry from
1688 * This isn't particularly optimized, but
1689 * well, this is supposed to be our worst-case
1690 * buffer only, and the socket buffer is
1691 * supposed to be our primary buffer, and if
1692 * it got full, then all bets are off
1695 bus->wqueue_size --;
1696 sd_bus_message_unref(bus->wqueue[0]);
1697 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1707 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1711 return bus_kernel_read_message(bus, hint_priority, priority);
1713 return bus_socket_read_message(bus);
1716 int bus_rqueue_make_room(sd_bus *bus) {
1719 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1722 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1728 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1733 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1735 /* Note that the priority logic is only available on kdbus,
1736 * where the rqueue is unused. We check the rqueue here
1737 * anyway, because it's simple... */
1740 if (bus->rqueue_size > 0) {
1741 /* Dispatch a queued message */
1743 *m = bus->rqueue[0];
1744 bus->rqueue_size --;
1745 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1749 /* Try to read a new message */
1750 r = bus_read_message(bus, hint_priority, priority);
1760 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1761 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1764 assert_return(m, -EINVAL);
1769 assert_return(!bus_pid_changed(bus), -ECHILD);
1770 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1772 if (!BUS_IS_OPEN(bus->state))
1776 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1783 /* If the cookie number isn't kept, then we know that no reply
1785 if (!cookie && !m->sealed)
1786 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1788 r = bus_seal_message(bus, m, 0);
1792 /* Remarshall if we have to. This will possibly unref the
1793 * message and place a replacement in m */
1794 r = bus_remarshal_message(bus, &m);
1798 /* If this is a reply and no reply was requested, then let's
1799 * suppress this, if we can */
1803 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1806 r = bus_write_message(bus, m, hint_sync_call, &idx);
1808 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1809 bus_enter_closing(bus);
1816 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1817 /* Wasn't fully written. So let's remember how
1818 * much was written. Note that the first entry
1819 * of the wqueue array is always allocated so
1820 * that we always can remember how much was
1822 bus->wqueue[0] = sd_bus_message_ref(m);
1823 bus->wqueue_size = 1;
1828 /* Just append it to the queue. */
1830 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1833 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1836 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1841 *cookie = BUS_MESSAGE_COOKIE(m);
1846 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1847 return bus_send_internal(bus, m, cookie, false);
1850 #if 0 /// UNNEEDED by elogind
1851 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1854 assert_return(m, -EINVAL);
1859 assert_return(!bus_pid_changed(bus), -ECHILD);
1861 if (!BUS_IS_OPEN(bus->state))
1864 if (!streq_ptr(m->destination, destination)) {
1869 r = sd_bus_message_set_destination(m, destination);
1874 return sd_bus_send(bus, m, cookie);
1878 static usec_t calc_elapse(uint64_t usec) {
1879 if (usec == (uint64_t) -1)
1882 return now(CLOCK_MONOTONIC) + usec;
1885 static int timeout_compare(const void *a, const void *b) {
1886 const struct reply_callback *x = a, *y = b;
1888 if (x->timeout != 0 && y->timeout == 0)
1891 if (x->timeout == 0 && y->timeout != 0)
1894 if (x->timeout < y->timeout)
1897 if (x->timeout > y->timeout)
1903 _public_ int sd_bus_call_async(
1907 sd_bus_message_handler_t callback,
1911 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1912 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1915 assert_return(m, -EINVAL);
1916 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1917 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1918 assert_return(callback, -EINVAL);
1923 assert_return(!bus_pid_changed(bus), -ECHILD);
1924 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1926 if (!BUS_IS_OPEN(bus->state))
1929 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1933 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1937 r = bus_seal_message(bus, m, usec);
1941 r = bus_remarshal_message(bus, &m);
1945 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1949 s->reply_callback.callback = callback;
1951 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1952 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1954 s->reply_callback.cookie = 0;
1958 s->reply_callback.timeout = calc_elapse(m->timeout);
1959 if (s->reply_callback.timeout != 0) {
1960 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1962 s->reply_callback.timeout = 0;
1967 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1978 int bus_ensure_running(sd_bus *bus) {
1983 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1985 if (bus->state == BUS_RUNNING)
1989 r = sd_bus_process(bus, NULL);
1992 if (bus->state == BUS_RUNNING)
1997 r = sd_bus_wait(bus, (uint64_t) -1);
2003 _public_ int sd_bus_call(
2007 sd_bus_error *error,
2008 sd_bus_message **reply) {
2010 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2016 bus_assert_return(m, -EINVAL, error);
2017 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2018 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2019 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2024 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2025 bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2027 if (!BUS_IS_OPEN(bus->state)) {
2032 r = bus_ensure_running(bus);
2036 i = bus->rqueue_size;
2038 r = bus_seal_message(bus, m, usec);
2042 r = bus_remarshal_message(bus, &m);
2046 r = bus_send_internal(bus, m, &cookie, true);
2050 timeout = calc_elapse(m->timeout);
2055 while (i < bus->rqueue_size) {
2056 sd_bus_message *incoming = NULL;
2058 incoming = bus->rqueue[i];
2060 if (incoming->reply_cookie == cookie) {
2061 /* Found a match! */
2063 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2065 log_debug_bus_message(incoming);
2067 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2069 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2073 sd_bus_message_unref(incoming);
2078 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2079 sd_bus_message_unref(incoming);
2082 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2083 r = sd_bus_error_copy(error, &incoming->error);
2084 sd_bus_message_unref(incoming);
2091 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2094 streq(bus->unique_name, incoming->sender)) {
2096 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2099 /* Our own message? Somebody is trying
2100 * to send its own client a message,
2101 * let's not dead-lock, let's fail
2104 sd_bus_message_unref(incoming);
2109 /* Try to read more, right-away */
2113 r = bus_read_message(bus, false, 0);
2115 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2116 bus_enter_closing(bus);
2128 n = now(CLOCK_MONOTONIC);
2136 left = (uint64_t) -1;
2138 r = bus_poll(bus, true, left);
2146 r = dispatch_wqueue(bus);
2148 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2149 bus_enter_closing(bus);
2158 return sd_bus_error_set_errno(error, r);
2161 #if 0 /// UNNEEDED by elogind
2162 _public_ int sd_bus_get_fd(sd_bus *bus) {
2164 assert_return(bus, -EINVAL);
2165 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2166 assert_return(!bus_pid_changed(bus), -ECHILD);
2168 return bus->input_fd;
2172 _public_ int sd_bus_get_events(sd_bus *bus) {
2175 assert_return(bus, -EINVAL);
2176 assert_return(!bus_pid_changed(bus), -ECHILD);
2178 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2181 if (bus->state == BUS_OPENING)
2183 else if (bus->state == BUS_AUTHENTICATING) {
2185 if (bus_socket_auth_needs_write(bus))
2190 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2191 if (bus->rqueue_size <= 0)
2193 if (bus->wqueue_size > 0)
2200 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2201 struct reply_callback *c;
2203 assert_return(bus, -EINVAL);
2204 assert_return(timeout_usec, -EINVAL);
2205 assert_return(!bus_pid_changed(bus), -ECHILD);
2207 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2210 if (bus->track_queue) {
2215 if (bus->state == BUS_CLOSING) {
2220 if (bus->state == BUS_AUTHENTICATING) {
2221 *timeout_usec = bus->auth_timeout;
2225 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2226 *timeout_usec = (uint64_t) -1;
2230 if (bus->rqueue_size > 0) {
2235 c = prioq_peek(bus->reply_callbacks_prioq);
2237 *timeout_usec = (uint64_t) -1;
2241 if (c->timeout == 0) {
2242 *timeout_usec = (uint64_t) -1;
2246 *timeout_usec = c->timeout;
2250 static int process_timeout(sd_bus *bus) {
2251 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2252 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2253 struct reply_callback *c;
2260 c = prioq_peek(bus->reply_callbacks_prioq);
2264 n = now(CLOCK_MONOTONIC);
2268 r = bus_message_new_synthetic_error(
2271 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2276 r = bus_seal_synthetic_message(bus, m);
2280 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2283 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2286 slot = container_of(c, sd_bus_slot, reply_callback);
2288 bus->iteration_counter ++;
2290 bus->current_message = m;
2291 bus->current_slot = sd_bus_slot_ref(slot);
2292 bus->current_handler = c->callback;
2293 bus->current_userdata = slot->userdata;
2294 r = c->callback(m, slot->userdata, &error_buffer);
2295 bus->current_userdata = NULL;
2296 bus->current_handler = NULL;
2297 bus->current_slot = NULL;
2298 bus->current_message = NULL;
2300 if (slot->floating) {
2301 bus_slot_disconnect(slot);
2302 sd_bus_slot_unref(slot);
2305 sd_bus_slot_unref(slot);
2307 return bus_maybe_reply_error(m, r, &error_buffer);
2310 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2314 if (bus->state != BUS_HELLO)
2317 /* Let's make sure the first message on the bus is the HELLO
2318 * reply. But note that we don't actually parse the message
2319 * here (we leave that to the usual handling), we just verify
2320 * we don't let any earlier msg through. */
2322 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2323 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2326 if (m->reply_cookie != 1)
2332 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2333 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2334 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2335 struct reply_callback *c;
2342 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2343 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2346 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2349 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2352 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2358 slot = container_of(c, sd_bus_slot, reply_callback);
2360 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2362 /* If the reply contained a file descriptor which we
2363 * didn't want we pass an error instead. */
2365 r = bus_message_new_synthetic_error(
2368 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2373 /* Copy over original timestamp */
2374 synthetic_reply->realtime = m->realtime;
2375 synthetic_reply->monotonic = m->monotonic;
2376 synthetic_reply->seqnum = m->seqnum;
2378 r = bus_seal_synthetic_message(bus, synthetic_reply);
2382 m = synthetic_reply;
2384 r = sd_bus_message_rewind(m, true);
2389 if (c->timeout != 0) {
2390 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2394 bus->current_slot = sd_bus_slot_ref(slot);
2395 bus->current_handler = c->callback;
2396 bus->current_userdata = slot->userdata;
2397 r = c->callback(m, slot->userdata, &error_buffer);
2398 bus->current_userdata = NULL;
2399 bus->current_handler = NULL;
2400 bus->current_slot = NULL;
2402 if (slot->floating) {
2403 bus_slot_disconnect(slot);
2404 sd_bus_slot_unref(slot);
2407 sd_bus_slot_unref(slot);
2409 return bus_maybe_reply_error(m, r, &error_buffer);
2412 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2413 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2414 struct filter_callback *l;
2421 bus->filter_callbacks_modified = false;
2423 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2426 if (bus->filter_callbacks_modified)
2429 /* Don't run this more than once per iteration */
2430 if (l->last_iteration == bus->iteration_counter)
2433 l->last_iteration = bus->iteration_counter;
2435 r = sd_bus_message_rewind(m, true);
2439 slot = container_of(l, sd_bus_slot, filter_callback);
2441 bus->current_slot = sd_bus_slot_ref(slot);
2442 bus->current_handler = l->callback;
2443 bus->current_userdata = slot->userdata;
2444 r = l->callback(m, slot->userdata, &error_buffer);
2445 bus->current_userdata = NULL;
2446 bus->current_handler = NULL;
2447 bus->current_slot = sd_bus_slot_unref(slot);
2449 r = bus_maybe_reply_error(m, r, &error_buffer);
2455 } while (bus->filter_callbacks_modified);
2460 static int process_match(sd_bus *bus, sd_bus_message *m) {
2467 bus->match_callbacks_modified = false;
2469 r = bus_match_run(bus, &bus->match_callbacks, m);
2473 } while (bus->match_callbacks_modified);
2478 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2479 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2485 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2488 if (bus->manual_peer_interface)
2491 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2494 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2497 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2500 if (streq_ptr(m->member, "Ping"))
2501 r = sd_bus_message_new_method_return(m, &reply);
2502 else if (streq_ptr(m->member, "GetMachineId")) {
2506 r = sd_id128_get_machine(&id);
2510 r = sd_bus_message_new_method_return(m, &reply);
2514 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2516 r = sd_bus_message_new_method_errorf(
2518 SD_BUS_ERROR_UNKNOWN_METHOD,
2519 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2525 r = sd_bus_send(bus, reply, NULL);
2532 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2536 /* If we got a message with a file descriptor which we didn't
2537 * want to accept, then let's drop it. How can this even
2538 * happen? For example, when the kernel queues a message into
2539 * an activatable names's queue which allows fds, and then is
2540 * delivered to us later even though we ourselves did not
2543 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2549 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2552 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2553 return 1; /* just eat it up */
2555 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2558 static int process_message(sd_bus *bus, sd_bus_message *m) {
2564 bus->current_message = m;
2565 bus->iteration_counter++;
2567 log_debug_bus_message(m);
2569 r = process_hello(bus, m);
2573 r = process_reply(bus, m);
2577 r = process_fd_check(bus, m);
2581 r = process_filter(bus, m);
2585 r = process_match(bus, m);
2589 r = process_builtin(bus, m);
2593 r = bus_process_object(bus, m);
2596 bus->current_message = NULL;
2600 static int dispatch_track(sd_bus *bus) {
2603 if (!bus->track_queue)
2606 bus_track_dispatch(bus->track_queue);
2610 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2611 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2615 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2617 r = process_timeout(bus);
2621 r = dispatch_wqueue(bus);
2625 r = dispatch_track(bus);
2629 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2635 r = process_message(bus, m);
2640 r = sd_bus_message_rewind(m, true);
2649 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2651 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2652 strna(sd_bus_message_get_sender(m)),
2653 strna(sd_bus_message_get_path(m)),
2654 strna(sd_bus_message_get_interface(m)),
2655 strna(sd_bus_message_get_member(m)));
2657 r = sd_bus_reply_method_errorf(
2659 SD_BUS_ERROR_UNKNOWN_OBJECT,
2660 "Unknown object '%s'.", m->path);
2674 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2675 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2676 struct reply_callback *c;
2680 assert(bus->state == BUS_CLOSING);
2682 c = ordered_hashmap_first(bus->reply_callbacks);
2684 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2687 /* First, fail all outstanding method calls */
2688 r = bus_message_new_synthetic_error(
2691 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2696 r = bus_seal_synthetic_message(bus, m);
2700 if (c->timeout != 0) {
2701 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2705 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2708 slot = container_of(c, sd_bus_slot, reply_callback);
2710 bus->iteration_counter++;
2712 bus->current_message = m;
2713 bus->current_slot = sd_bus_slot_ref(slot);
2714 bus->current_handler = c->callback;
2715 bus->current_userdata = slot->userdata;
2716 r = c->callback(m, slot->userdata, &error_buffer);
2717 bus->current_userdata = NULL;
2718 bus->current_handler = NULL;
2719 bus->current_slot = NULL;
2720 bus->current_message = NULL;
2722 if (slot->floating) {
2723 bus_slot_disconnect(slot);
2724 sd_bus_slot_unref(slot);
2727 sd_bus_slot_unref(slot);
2729 return bus_maybe_reply_error(m, r, &error_buffer);
2732 /* Then, synthesize a Disconnected message */
2733 r = sd_bus_message_new_signal(
2736 "/org/freedesktop/DBus/Local",
2737 "org.freedesktop.DBus.Local",
2742 bus_message_set_sender_local(bus, m);
2744 r = bus_seal_synthetic_message(bus, m);
2750 bus->current_message = m;
2751 bus->iteration_counter++;
2753 r = process_filter(bus, m);
2757 r = process_match(bus, m);
2769 bus->current_message = NULL;
2774 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2775 BUS_DONT_DESTROY(bus);
2778 /* Returns 0 when we didn't do anything. This should cause the
2779 * caller to invoke sd_bus_wait() before returning the next
2780 * time. Returns > 0 when we did something, which possibly
2781 * means *ret is filled in with an unprocessed message. */
2783 assert_return(bus, -EINVAL);
2784 assert_return(!bus_pid_changed(bus), -ECHILD);
2786 /* We don't allow recursively invoking sd_bus_process(). */
2787 assert_return(!bus->current_message, -EBUSY);
2788 assert(!bus->current_slot);
2790 switch (bus->state) {
2799 r = bus_socket_process_opening(bus);
2800 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2801 bus_enter_closing(bus);
2809 case BUS_AUTHENTICATING:
2810 r = bus_socket_process_authenticating(bus);
2811 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2812 bus_enter_closing(bus);
2824 r = process_running(bus, hint_priority, priority, ret);
2825 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2826 bus_enter_closing(bus);
2836 return process_closing(bus, ret);
2839 assert_not_reached("Unknown state");
2842 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2843 return bus_process_internal(bus, false, 0, ret);
2846 #if 0 /// UNNEEDED by elogind
2847 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2848 return bus_process_internal(bus, true, priority, ret);
2852 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2853 struct pollfd p[2] = {};
2856 usec_t m = USEC_INFINITY;
2860 if (bus->state == BUS_CLOSING)
2863 if (!BUS_IS_OPEN(bus->state))
2866 e = sd_bus_get_events(bus);
2871 /* The caller really needs some more data, he doesn't
2872 * care about what's already read, or any timeouts
2873 * except its own. */
2877 /* The caller wants to process if there's something to
2878 * process, but doesn't care otherwise */
2880 r = sd_bus_get_timeout(bus, &until);
2885 nw = now(CLOCK_MONOTONIC);
2886 m = until > nw ? until - nw : 0;
2890 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2893 p[0].fd = bus->input_fd;
2894 if (bus->output_fd == bus->input_fd) {
2898 p[0].events = e & POLLIN;
2899 p[1].fd = bus->output_fd;
2900 p[1].events = e & POLLOUT;
2904 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2908 return r > 0 ? 1 : 0;
2911 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2913 assert_return(bus, -EINVAL);
2914 assert_return(!bus_pid_changed(bus), -ECHILD);
2916 if (bus->state == BUS_CLOSING)
2919 if (!BUS_IS_OPEN(bus->state))
2922 if (bus->rqueue_size > 0)
2925 return bus_poll(bus, false, timeout_usec);
2928 _public_ int sd_bus_flush(sd_bus *bus) {
2931 assert_return(bus, -EINVAL);
2932 assert_return(!bus_pid_changed(bus), -ECHILD);
2934 if (bus->state == BUS_CLOSING)
2937 if (!BUS_IS_OPEN(bus->state))
2940 r = bus_ensure_running(bus);
2944 if (bus->wqueue_size <= 0)
2948 r = dispatch_wqueue(bus);
2950 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2951 bus_enter_closing(bus);
2958 if (bus->wqueue_size <= 0)
2961 r = bus_poll(bus, false, (uint64_t) -1);
2967 #if 0 /// UNNEEDED by elogind
2968 _public_ int sd_bus_add_filter(
2971 sd_bus_message_handler_t callback,
2976 assert_return(bus, -EINVAL);
2977 assert_return(callback, -EINVAL);
2978 assert_return(!bus_pid_changed(bus), -ECHILD);
2980 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2984 s->filter_callback.callback = callback;
2986 bus->filter_callbacks_modified = true;
2987 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2996 _public_ int sd_bus_add_match(
3000 sd_bus_message_handler_t callback,
3003 struct bus_match_component *components = NULL;
3004 unsigned n_components = 0;
3005 sd_bus_slot *s = NULL;
3008 assert_return(bus, -EINVAL);
3009 assert_return(match, -EINVAL);
3010 assert_return(!bus_pid_changed(bus), -ECHILD);
3012 r = bus_match_parse(match, &components, &n_components);
3016 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3022 s->match_callback.callback = callback;
3023 s->match_callback.cookie = ++bus->match_cookie;
3025 if (bus->bus_client) {
3026 enum bus_match_scope scope;
3028 scope = bus_match_get_scope(components, n_components);
3030 /* Do not install server-side matches for matches
3031 * against the local service, interface or bus
3033 if (scope != BUS_MATCH_LOCAL) {
3035 if (!bus->is_kernel) {
3036 /* When this is not a kernel transport, we
3037 * store the original match string, so that we
3038 * can use it to remove the match again */
3040 s->match_callback.match_string = strdup(match);
3041 if (!s->match_callback.match_string) {
3047 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3051 s->match_added = true;
3055 bus->match_callbacks_modified = true;
3056 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3065 bus_match_parse_free(components, n_components);
3066 sd_bus_slot_unref(s);
3071 #if 0 /// UNNEEDED by elogind
3072 int bus_remove_match_by_string(
3075 sd_bus_message_handler_t callback,
3078 struct bus_match_component *components = NULL;
3079 unsigned n_components = 0;
3080 struct match_callback *c;
3083 assert_return(bus, -EINVAL);
3084 assert_return(match, -EINVAL);
3085 assert_return(!bus_pid_changed(bus), -ECHILD);
3087 r = bus_match_parse(match, &components, &n_components);
3091 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3095 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3098 bus_match_parse_free(components, n_components);
3104 bool bus_pid_changed(sd_bus *bus) {
3107 /* We don't support people creating a bus connection and
3108 * keeping it around over a fork(). Let's complain. */
3110 return bus->original_pid != getpid();
3113 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3114 sd_bus *bus = userdata;
3119 r = sd_bus_process(bus, NULL);
3126 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3127 sd_bus *bus = userdata;
3132 r = sd_bus_process(bus, NULL);
3139 static int prepare_callback(sd_event_source *s, void *userdata) {
3140 sd_bus *bus = userdata;
3147 e = sd_bus_get_events(bus);
3151 if (bus->output_fd != bus->input_fd) {
3153 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3157 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3161 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3166 r = sd_bus_get_timeout(bus, &until);
3172 j = sd_event_source_set_time(bus->time_event_source, until);
3177 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3184 static int quit_callback(sd_event_source *event, void *userdata) {
3185 sd_bus *bus = userdata;
3195 static int attach_io_events(sd_bus *bus) {
3200 if (bus->input_fd < 0)
3206 if (!bus->input_io_event_source) {
3207 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3211 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3215 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3219 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3221 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3226 if (bus->output_fd != bus->input_fd) {
3227 assert(bus->output_fd >= 0);
3229 if (!bus->output_io_event_source) {
3230 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3234 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3238 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3240 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3249 static void detach_io_events(sd_bus *bus) {
3252 if (bus->input_io_event_source) {
3253 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3254 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3257 if (bus->output_io_event_source) {
3258 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3259 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3263 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3266 assert_return(bus, -EINVAL);
3267 assert_return(!bus->event, -EBUSY);
3269 assert(!bus->input_io_event_source);
3270 assert(!bus->output_io_event_source);
3271 assert(!bus->time_event_source);
3274 bus->event = sd_event_ref(event);
3276 r = sd_event_default(&bus->event);
3281 bus->event_priority = priority;
3283 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3287 r = sd_event_source_set_priority(bus->time_event_source, priority);
3291 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3295 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3299 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3303 r = attach_io_events(bus);
3310 sd_bus_detach_event(bus);
3314 _public_ int sd_bus_detach_event(sd_bus *bus) {
3315 assert_return(bus, -EINVAL);
3320 detach_io_events(bus);
3322 if (bus->time_event_source) {
3323 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3324 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3327 if (bus->quit_event_source) {
3328 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3329 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3332 bus->event = sd_event_unref(bus->event);
3336 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3337 assert_return(bus, NULL);
3342 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3343 assert_return(bus, NULL);
3345 return bus->current_message;
3348 #if 0 /// UNNEEDED by elogind
3349 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3350 assert_return(bus, NULL);
3352 return bus->current_slot;
3356 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3357 assert_return(bus, NULL);
3359 return bus->current_handler;
3362 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3363 assert_return(bus, NULL);
3365 return bus->current_userdata;
3368 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3373 assert(default_bus);
3376 return !!*default_bus;
3379 *ret = sd_bus_ref(*default_bus);
3387 b->default_bus_ptr = default_bus;
3395 _public_ int sd_bus_default_system(sd_bus **ret) {
3396 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3400 _public_ int sd_bus_default_user(sd_bus **ret) {
3401 /// elogind does not support user buses
3403 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3405 return sd_bus_default_system(ret);
3409 _public_ int sd_bus_default(sd_bus **ret) {
3413 /* Let's try our best to reuse another cached connection. If
3414 * the starter bus type is set, connect via our normal
3415 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3416 * we can share the connection with the user/system default
3419 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3421 if (streq(e, "system"))
3422 return sd_bus_default_system(ret);
3423 /// elogind does not support systemd units
3425 else if (STR_IN_SET(e, "user", "session"))
3426 return sd_bus_default_user(ret);
3430 /* No type is specified, so we have not other option than to
3431 * use the starter address if it is set. */
3433 e = secure_getenv("DBUS_STARTER_ADDRESS");
3436 return bus_default(sd_bus_open, &default_starter_bus, ret);
3439 /* Finally, if nothing is set use the cached connection for
3440 * the right scope */
3442 /// elogind does not support systemd units
3444 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3445 return sd_bus_default_user(ret);
3448 return sd_bus_default_system(ret);
3451 #if 0 /// UNNEEDED by elogind
3452 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3453 assert_return(b, -EINVAL);
3454 assert_return(tid, -EINVAL);
3455 assert_return(!bus_pid_changed(b), -ECHILD);
3463 return sd_event_get_tid(b->event, tid);
3468 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3469 _cleanup_free_ char *e = NULL;
3472 assert_return(object_path_is_valid(prefix), -EINVAL);
3473 assert_return(external_id, -EINVAL);
3474 assert_return(ret_path, -EINVAL);
3476 e = bus_label_escape(external_id);
3480 ret = strjoin(prefix, "/", e, NULL);
3488 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3492 assert_return(object_path_is_valid(path), -EINVAL);
3493 assert_return(object_path_is_valid(prefix), -EINVAL);
3494 assert_return(external_id, -EINVAL);
3496 e = object_path_startswith(path, prefix);
3498 *external_id = NULL;
3502 ret = bus_label_unescape(e);
3510 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3511 _cleanup_strv_free_ char **labels = NULL;
3512 char *path, *path_pos, **label_pos;
3513 const char *sep, *template_pos;
3518 assert_return(out, -EINVAL);
3519 assert_return(path_template, -EINVAL);
3521 path_length = strlen(path_template);
3523 va_start(list, path_template);
3524 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3528 arg = va_arg(list, const char *);
3534 label = bus_label_escape(arg);
3540 r = strv_consume(&labels, label);
3546 /* add label length, but account for the format character */
3547 path_length += strlen(label) - 1;
3551 path = malloc(path_length + 1);
3558 for (template_pos = path_template; *template_pos; ) {
3559 sep = strchrnul(template_pos, '%');
3560 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3564 path_pos = stpcpy(path_pos, *label_pos++);
3565 template_pos = sep + 1;
3573 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3574 _cleanup_strv_free_ char **labels = NULL;
3575 const char *template_pos, *path_pos;
3581 * This decodes an object-path based on a template argument. The
3582 * template consists of a verbatim path, optionally including special
3585 * - Each occurrence of '%' in the template matches an arbitrary
3586 * substring of a label in the given path. At most one such
3587 * directive is allowed per label. For each such directive, the
3588 * caller must provide an output parameter (char **) via va_arg. If
3589 * NULL is passed, the given label is verified, but not returned.
3590 * For each matched label, the *decoded* label is stored in the
3591 * passed output argument, and the caller is responsible to free
3592 * it. Note that the output arguments are only modified if the
3593 * actualy path matched the template. Otherwise, they're left
3596 * This function returns <0 on error, 0 if the path does not match the
3597 * template, 1 if it matched.
3600 assert_return(path, -EINVAL);
3601 assert_return(path_template, -EINVAL);
3605 for (template_pos = path_template; *template_pos; ) {
3610 /* verify everything until the next '%' matches verbatim */
3611 sep = strchrnul(template_pos, '%');
3612 length = sep - template_pos;
3613 if (strncmp(path_pos, template_pos, length))
3617 template_pos += length;
3622 /* We found the next '%' character. Everything up until here
3623 * matched. We now skip ahead to the end of this label and make
3624 * sure it matches the tail of the label in the path. Then we
3625 * decode the string in-between and save it for later use. */
3627 ++template_pos; /* skip over '%' */
3629 sep = strchrnul(template_pos, '/');
3630 length = sep - template_pos; /* length of suffix to match verbatim */
3632 /* verify the suffixes match */
3633 sep = strchrnul(path_pos, '/');
3634 if (sep - path_pos < (ssize_t)length ||
3635 strncmp(sep - length, template_pos, length))
3638 template_pos += length; /* skip over matched label */
3639 length = sep - path_pos - length; /* length of sub-label to decode */
3641 /* store unescaped label for later use */
3642 label = bus_label_unescape_n(path_pos, length);
3646 r = strv_consume(&labels, label);
3650 path_pos = sep; /* skip decoded label and suffix */
3653 /* end of template must match end of path */
3657 /* copy the labels over to the caller */
3658 va_start(list, path_template);
3659 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3662 arg = va_arg(list, char **);
3675 _public_ int sd_bus_try_close(sd_bus *bus) {
3678 assert_return(bus, -EINVAL);
3679 assert_return(!bus_pid_changed(bus), -ECHILD);
3681 if (!bus->is_kernel)
3684 if (!BUS_IS_OPEN(bus->state))
3687 if (bus->rqueue_size > 0)
3690 if (bus->wqueue_size > 0)
3693 r = bus_kernel_try_close(bus);
3701 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3702 assert_return(bus, -EINVAL);
3703 assert_return(description, -EINVAL);
3704 assert_return(bus->description, -ENXIO);
3705 assert_return(!bus_pid_changed(bus), -ECHILD);
3707 *description = bus->description;
3712 int bus_get_root_path(sd_bus *bus) {
3715 if (bus->cgroup_root)
3718 r = cg_get_root_path(&bus->cgroup_root);
3720 bus->cgroup_root = strdup("/");
3721 if (!bus->cgroup_root)
3730 #if 0 /// UNNEEDED by elogind
3731 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3734 assert_return(bus, -EINVAL);
3735 assert_return(scope, -EINVAL);
3736 assert_return(!bus_pid_changed(bus), -ECHILD);
3738 if (bus->is_kernel) {
3739 _cleanup_free_ char *n = NULL;
3742 r = bus_kernel_get_bus_name(bus, &n);
3746 if (streq(n, "0-system")) {
3751 dash = strchr(n, '-');
3752 if (streq_ptr(dash, "-user")) {
3763 if (bus->is_system) {
3771 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3773 assert_return(bus, -EINVAL);
3774 assert_return(address, -EINVAL);
3775 assert_return(!bus_pid_changed(bus), -ECHILD);
3778 *address = bus->address;
3785 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3786 assert_return(bus, -EINVAL);
3787 assert_return(mask, -EINVAL);
3788 assert_return(!bus_pid_changed(bus), -ECHILD);
3790 *mask = bus->creds_mask;
3794 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3795 assert_return(bus, -EINVAL);
3796 assert_return(!bus_pid_changed(bus), -ECHILD);
3798 return bus->bus_client;
3801 _public_ int sd_bus_is_server(sd_bus *bus) {
3802 assert_return(bus, -EINVAL);
3803 assert_return(!bus_pid_changed(bus), -ECHILD);
3805 return bus->is_server;
3808 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3809 assert_return(bus, -EINVAL);
3810 assert_return(!bus_pid_changed(bus), -ECHILD);
3812 return bus->anonymous_auth;
3815 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3816 assert_return(bus, -EINVAL);
3817 assert_return(!bus_pid_changed(bus), -ECHILD);
3819 return bus->trusted;
3822 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3823 assert_return(bus, -EINVAL);
3824 assert_return(!bus_pid_changed(bus), -ECHILD);
3826 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3829 static void flush_close(sd_bus *bus) {
3833 /* Flushes and closes the specified bus. We take a ref before,
3834 * to ensure the flushing does not cause the bus to be
3837 sd_bus_flush_close_unref(sd_bus_ref(bus));
3840 _public_ void sd_bus_default_flush_close(void) {
3841 flush_close(default_starter_bus);
3842 flush_close(default_user_bus);
3843 flush_close(default_system_bus);