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/>.
38 #include "cgroup-util.h"
39 #include "bus-label.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
54 #include "bus-track.h"
57 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
58 static int attach_io_events(sd_bus *b);
59 static void detach_io_events(sd_bus *b);
61 static void bus_close_fds(sd_bus *b) {
67 safe_close(b->input_fd);
69 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
70 safe_close(b->output_fd);
72 b->input_fd = b->output_fd = -1;
75 static void bus_reset_queues(sd_bus *b) {
78 while (b->rqueue_size > 0)
79 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
83 b->rqueue_allocated = 0;
85 while (b->wqueue_size > 0)
86 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
90 b->wqueue_allocated = 0;
93 static void bus_free(sd_bus *b) {
97 assert(!b->track_queue);
99 b->state = BUS_CLOSED;
101 sd_bus_detach_event(b);
103 while ((s = b->slots)) {
104 /* At this point only floating slots can still be
105 * around, because the non-floating ones keep a
106 * reference to the bus, and we thus couldn't be
107 * destructing right now... We forcibly disconnect the
108 * slots here, so that they still can be referenced by
109 * apps, but are dead. */
112 bus_slot_disconnect(s);
113 sd_bus_slot_unref(s);
116 if (b->default_bus_ptr)
117 *b->default_bus_ptr = NULL;
122 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
125 free(b->unique_name);
126 free(b->auth_buffer);
131 free(b->cgroup_root);
132 free(b->connection_name);
135 strv_free(b->exec_argv);
137 close_many(b->fds, b->n_fds);
142 ordered_hashmap_free_free(b->reply_callbacks);
143 prioq_free(b->reply_callbacks_prioq);
145 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
146 bus_match_free(&b->match_callbacks);
148 hashmap_free_free(b->vtable_methods);
149 hashmap_free_free(b->vtable_properties);
151 assert(hashmap_isempty(b->nodes));
152 hashmap_free(b->nodes);
154 bus_kernel_flush_memfd(b);
156 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
161 _public_ int sd_bus_new(sd_bus **ret) {
164 assert_return(ret, -EINVAL);
170 r->n_ref = REFCNT_INIT;
171 r->input_fd = r->output_fd = -1;
172 r->message_version = 1;
173 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
174 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
175 r->attach_flags |= KDBUS_ATTACH_NAMES;
176 r->original_pid = getpid();
178 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
180 /* We guarantee that wqueue always has space for at least one
182 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
191 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
194 assert_return(bus, -EINVAL);
195 assert_return(bus->state == BUS_UNSET, -EPERM);
196 assert_return(address, -EINVAL);
197 assert_return(!bus_pid_changed(bus), -ECHILD);
209 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
210 assert_return(bus, -EINVAL);
211 assert_return(bus->state == BUS_UNSET, -EPERM);
212 assert_return(input_fd >= 0, -EINVAL);
213 assert_return(output_fd >= 0, -EINVAL);
214 assert_return(!bus_pid_changed(bus), -ECHILD);
216 bus->input_fd = input_fd;
217 bus->output_fd = output_fd;
221 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
224 assert_return(bus, -EINVAL);
225 assert_return(bus->state == BUS_UNSET, -EPERM);
226 assert_return(path, -EINVAL);
227 assert_return(!strv_isempty(argv), -EINVAL);
228 assert_return(!bus_pid_changed(bus), -ECHILD);
240 free(bus->exec_path);
241 strv_free(bus->exec_argv);
249 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
250 assert_return(bus, -EINVAL);
251 assert_return(bus->state == BUS_UNSET, -EPERM);
252 assert_return(!bus_pid_changed(bus), -ECHILD);
254 bus->bus_client = !!b;
258 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
259 assert_return(bus, -EINVAL);
260 assert_return(bus->state == BUS_UNSET, -EPERM);
261 assert_return(!bus_pid_changed(bus), -ECHILD);
263 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
267 _public_ int sd_bus_negotiate_fds(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 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
276 _public_ int sd_bus_negotiate_timestamp(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->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
285 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
286 assert_return(bus, -EINVAL);
287 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
288 assert_return(bus->state == BUS_UNSET, -EPERM);
289 assert_return(!bus_pid_changed(bus), -ECHILD);
291 /* The well knowns we need unconditionally, so that matches can work */
292 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
294 return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags);
297 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
298 assert_return(bus, -EINVAL);
299 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
300 assert_return(bus->state == BUS_UNSET, -EPERM);
301 assert_return(!bus_pid_changed(bus), -ECHILD);
303 bus->is_server = !!b;
304 bus->server_id = server_id;
308 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
309 assert_return(bus, -EINVAL);
310 assert_return(bus->state == BUS_UNSET, -EPERM);
311 assert_return(!bus_pid_changed(bus), -ECHILD);
313 bus->anonymous_auth = !!b;
317 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
318 assert_return(bus, -EINVAL);
319 assert_return(bus->state == BUS_UNSET, -EPERM);
320 assert_return(!bus_pid_changed(bus), -ECHILD);
326 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
329 assert_return(bus, -EINVAL);
330 assert_return(name, -EINVAL);
331 assert_return(bus->state == BUS_UNSET, -EPERM);
332 assert_return(!bus_pid_changed(bus), -ECHILD);
338 free(bus->connection_name);
339 bus->connection_name = n;
344 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
349 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
352 r = sd_bus_message_get_errno(reply);
356 r = sd_bus_message_read(reply, "s", &s);
360 if (!service_name_is_valid(s) || s[0] != ':')
363 bus->unique_name = strdup(s);
364 if (!bus->unique_name)
367 if (bus->state == BUS_HELLO)
368 bus->state = BUS_RUNNING;
373 static int bus_send_hello(sd_bus *bus) {
374 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
379 if (!bus->bus_client || bus->is_kernel)
382 r = sd_bus_message_new_method_call(
385 "org.freedesktop.DBus",
386 "/org/freedesktop/DBus",
387 "org.freedesktop.DBus",
392 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
395 int bus_start_running(sd_bus *bus) {
398 if (bus->bus_client && !bus->is_kernel) {
399 bus->state = BUS_HELLO;
403 bus->state = BUS_RUNNING;
407 static int parse_address_key(const char **p, const char *key, char **value) {
408 size_t l, n = 0, allocated = 0;
418 if (strncmp(*p, key, l) != 0)
431 while (*a != ';' && *a != ',' && *a != 0) {
449 c = (char) ((x << 4) | y);
456 if (!GREEDY_REALLOC(r, allocated, n + 2))
480 static void skip_address_key(const char **p) {
484 *p += strcspn(*p, ",");
490 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
491 _cleanup_free_ char *path = NULL, *abstract = NULL;
500 while (**p != 0 && **p != ';') {
501 r = parse_address_key(p, "guid", guid);
507 r = parse_address_key(p, "path", &path);
513 r = parse_address_key(p, "abstract", &abstract);
522 if (!path && !abstract)
525 if (path && abstract)
530 if (l > sizeof(b->sockaddr.un.sun_path))
533 b->sockaddr.un.sun_family = AF_UNIX;
534 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
535 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
536 } else if (abstract) {
537 l = strlen(abstract);
538 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
541 b->sockaddr.un.sun_family = AF_UNIX;
542 b->sockaddr.un.sun_path[0] = 0;
543 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
544 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
550 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
551 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
553 struct addrinfo *result, hints = {
554 .ai_socktype = SOCK_STREAM,
555 .ai_flags = AI_ADDRCONFIG,
563 while (**p != 0 && **p != ';') {
564 r = parse_address_key(p, "guid", guid);
570 r = parse_address_key(p, "host", &host);
576 r = parse_address_key(p, "port", &port);
582 r = parse_address_key(p, "family", &family);
595 if (streq(family, "ipv4"))
596 hints.ai_family = AF_INET;
597 else if (streq(family, "ipv6"))
598 hints.ai_family = AF_INET6;
603 r = getaddrinfo(host, port, &hints, &result);
607 return -EADDRNOTAVAIL;
609 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
610 b->sockaddr_size = result->ai_addrlen;
612 freeaddrinfo(result);
617 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
619 unsigned n_argv = 0, j;
621 size_t allocated = 0;
629 while (**p != 0 && **p != ';') {
630 r = parse_address_key(p, "guid", guid);
636 r = parse_address_key(p, "path", &path);
642 if (startswith(*p, "argv")) {
646 ul = strtoul(*p + 4, (char**) p, 10);
647 if (errno > 0 || **p != '=' || ul > 256) {
655 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
663 r = parse_address_key(p, NULL, argv + ul);
678 /* Make sure there are no holes in the array, with the
679 * exception of argv[0] */
680 for (j = 1; j < n_argv; j++)
686 if (argv && argv[0] == NULL) {
687 argv[0] = strdup(path);
699 for (j = 0; j < n_argv; j++)
707 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
708 _cleanup_free_ char *path = NULL;
716 while (**p != 0 && **p != ';') {
717 r = parse_address_key(p, "guid", guid);
723 r = parse_address_key(p, "path", &path);
742 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
743 _cleanup_free_ char *machine = NULL;
751 while (**p != 0 && **p != ';') {
752 r = parse_address_key(p, "guid", guid);
758 r = parse_address_key(p, "machine", &machine);
770 if (!machine_name_is_valid(machine))
774 b->machine = machine;
777 b->sockaddr.un.sun_family = AF_UNIX;
778 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
779 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
784 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
785 _cleanup_free_ char *machine = NULL;
793 while (**p != 0 && **p != ';') {
794 r = parse_address_key(p, "guid", guid);
800 r = parse_address_key(p, "machine", &machine);
812 if (!machine_name_is_valid(machine))
816 b->machine = machine;
820 b->kernel = strdup("/dev/kdbus/0-system/bus");
827 static void bus_reset_parsed_address(sd_bus *b) {
831 b->sockaddr_size = 0;
832 strv_free(b->exec_argv);
836 b->server_id = SD_ID128_NULL;
843 static int bus_parse_next_address(sd_bus *b) {
844 _cleanup_free_ char *guid = NULL;
852 if (b->address[b->address_index] == 0)
855 bus_reset_parsed_address(b);
857 a = b->address + b->address_index;
866 if (startswith(a, "unix:")) {
869 r = parse_unix_address(b, &a, &guid);
874 } else if (startswith(a, "tcp:")) {
877 r = parse_tcp_address(b, &a, &guid);
883 } else if (startswith(a, "unixexec:")) {
886 r = parse_exec_address(b, &a, &guid);
892 } else if (startswith(a, "kernel:")) {
895 r = parse_kernel_address(b, &a, &guid);
900 } else if (startswith(a, "x-container-unix:")) {
903 r = parse_container_unix_address(b, &a, &guid);
908 } else if (startswith(a, "x-container-kernel:")) {
911 r = parse_container_kernel_address(b, &a, &guid);
924 r = sd_id128_from_string(guid, &b->server_id);
929 b->address_index = a - b->address;
933 static int bus_start_address(sd_bus *b) {
939 bool skipped = false;
944 r = bus_socket_exec(b);
945 else if (b->machine && b->kernel)
946 r = bus_container_connect_kernel(b);
947 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
948 r = bus_container_connect_socket(b);
950 r = bus_kernel_connect(b);
951 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
952 r = bus_socket_connect(b);
958 r = attach_io_events(b);
963 b->last_connect_error = -r;
966 r = bus_parse_next_address(b);
970 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
974 int bus_next_address(sd_bus *b) {
977 bus_reset_parsed_address(b);
978 return bus_start_address(b);
981 static int bus_start_fd(sd_bus *b) {
986 assert(b->input_fd >= 0);
987 assert(b->output_fd >= 0);
989 r = fd_nonblock(b->input_fd, true);
993 r = fd_cloexec(b->input_fd, true);
997 if (b->input_fd != b->output_fd) {
998 r = fd_nonblock(b->output_fd, true);
1002 r = fd_cloexec(b->output_fd, true);
1007 if (fstat(b->input_fd, &st) < 0)
1010 if (S_ISCHR(b->input_fd))
1011 return bus_kernel_take_fd(b);
1013 return bus_socket_take_fd(b);
1016 _public_ int sd_bus_start(sd_bus *bus) {
1019 assert_return(bus, -EINVAL);
1020 assert_return(bus->state == BUS_UNSET, -EPERM);
1021 assert_return(!bus_pid_changed(bus), -ECHILD);
1023 bus->state = BUS_OPENING;
1025 if (bus->is_server && bus->bus_client)
1028 if (bus->input_fd >= 0)
1029 r = bus_start_fd(bus);
1030 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1031 r = bus_start_address(bus);
1040 return bus_send_hello(bus);
1043 _public_ int sd_bus_open(sd_bus **ret) {
1048 assert_return(ret, -EINVAL);
1050 /* Let's connect to the starter bus if it is set, and
1051 * otherwise to the bus that is appropropriate for the scope
1052 * we are running in */
1054 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1056 if (streq(e, "system"))
1057 return sd_bus_open_system(ret);
1058 else if (STR_IN_SET(e, "session", "user"))
1059 return sd_bus_open_user(ret);
1062 e = secure_getenv("DBUS_STARTER_ADDRESS");
1064 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1065 return sd_bus_open_user(ret);
1067 return sd_bus_open_system(ret);
1074 r = sd_bus_set_address(b, e);
1078 b->bus_client = true;
1080 /* We don't know whether the bus is trusted or not, so better
1081 * be safe, and authenticate everything */
1083 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1085 r = sd_bus_start(b);
1097 int bus_set_address_system(sd_bus *b) {
1101 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1103 return sd_bus_set_address(b, e);
1105 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1108 _public_ int sd_bus_open_system(sd_bus **ret) {
1112 assert_return(ret, -EINVAL);
1118 r = bus_set_address_system(b);
1122 b->bus_client = true;
1123 b->is_system = true;
1125 /* Let's do per-method access control on the system bus. We
1126 * need the caller's UID and capability set for that. */
1128 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1130 r = sd_bus_start(b);
1142 int bus_set_address_user(sd_bus *b) {
1147 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1149 return sd_bus_set_address(b, e);
1151 e = secure_getenv("XDG_RUNTIME_DIR");
1153 _cleanup_free_ char *ee = NULL;
1155 ee = bus_address_escape(e);
1160 (void) asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1162 (void) asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1166 (void) asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1168 return -ECONNREFUSED;
1178 _public_ int sd_bus_open_user(sd_bus **ret) {
1182 assert_return(ret, -EINVAL);
1188 r = bus_set_address_user(b);
1192 b->bus_client = true;
1195 /* We don't do any per-method access control on the user
1199 r = sd_bus_start(b);
1211 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1212 _cleanup_free_ char *e = NULL;
1213 char *m = NULL, *c = NULL;
1218 /* Let's see if we shall enter some container */
1219 m = strchr(host, ':');
1223 /* Let's make sure this is not a port of some kind,
1224 * and is a valid machine name. */
1225 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1228 /* Cut out the host part */
1229 t = strndupa(host, m - host - 1);
1230 e = bus_address_escape(t);
1234 c = strappenda(",argv4=--machine=", m);
1239 e = bus_address_escape(host);
1244 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1251 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1255 assert_return(host, -EINVAL);
1256 assert_return(ret, -EINVAL);
1258 r = sd_bus_new(&bus);
1262 r = bus_set_address_system_remote(bus, host);
1266 bus->bus_client = true;
1267 bus->trusted = false;
1269 r = sd_bus_start(bus);
1281 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1282 _cleanup_free_ char *e = NULL;
1287 e = bus_address_escape(machine);
1292 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1294 b->address = strjoin("x-container-unix:machine=", e, NULL);
1302 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1306 assert_return(machine, -EINVAL);
1307 assert_return(ret, -EINVAL);
1308 assert_return(machine_name_is_valid(machine), -EINVAL);
1310 r = sd_bus_new(&bus);
1314 r = bus_set_address_system_container(bus, machine);
1318 bus->bus_client = true;
1319 bus->trusted = false;
1321 r = sd_bus_start(bus);
1333 _public_ void sd_bus_close(sd_bus *bus) {
1337 if (bus->state == BUS_CLOSED)
1339 if (bus_pid_changed(bus))
1342 bus->state = BUS_CLOSED;
1344 sd_bus_detach_event(bus);
1346 /* Drop all queued messages so that they drop references to
1347 * the bus object and the bus may be freed */
1348 bus_reset_queues(bus);
1350 if (!bus->is_kernel)
1353 /* We'll leave the fd open in case this is a kernel bus, since
1354 * there might still be memblocks around that reference this
1355 * bus, and they might need to invoke the KDBUS_CMD_FREE
1356 * ioctl on the fd when they are freed. */
1359 static void bus_enter_closing(sd_bus *bus) {
1362 if (bus->state != BUS_OPENING &&
1363 bus->state != BUS_AUTHENTICATING &&
1364 bus->state != BUS_HELLO &&
1365 bus->state != BUS_RUNNING)
1368 bus->state = BUS_CLOSING;
1371 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1372 assert_return(bus, NULL);
1374 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1379 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1385 i = REFCNT_DEC(bus->n_ref);
1393 _public_ int sd_bus_is_open(sd_bus *bus) {
1395 assert_return(bus, -EINVAL);
1396 assert_return(!bus_pid_changed(bus), -ECHILD);
1398 return BUS_IS_OPEN(bus->state);
1401 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1404 assert_return(bus, -EINVAL);
1405 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1406 assert_return(!bus_pid_changed(bus), -ECHILD);
1408 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1411 if (type == SD_BUS_TYPE_UNIX_FD) {
1412 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1415 r = bus_ensure_running(bus);
1419 return bus->can_fds;
1422 return bus_type_is_valid(type);
1425 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1428 assert_return(bus, -EINVAL);
1429 assert_return(server_id, -EINVAL);
1430 assert_return(!bus_pid_changed(bus), -ECHILD);
1432 r = bus_ensure_running(bus);
1436 *server_id = bus->server_id;
1440 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1445 /* If we copy the same message to multiple
1446 * destinations, avoid using the same cookie
1448 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1453 timeout = BUS_DEFAULT_TIMEOUT;
1455 return bus_message_seal(m, ++b->cookie, timeout);
1458 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1461 /* Do packet version and endianness already match? */
1462 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1463 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1466 /* No? Then remarshal! */
1467 return bus_message_remarshal(b, m);
1470 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1474 /* The bus specification says the serial number cannot be 0,
1475 * hence let's fill something in for synthetic messages. Since
1476 * synthetic messages might have a fake sender and we don't
1477 * want to interfere with the real sender's serial numbers we
1478 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1479 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1480 * even though kdbus can do 64bit. */
1482 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1485 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1492 r = bus_kernel_write_message(bus, m, hint_sync_call);
1494 r = bus_socket_write_message(bus, m, idx);
1499 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1500 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1501 bus_message_type_to_string(m->header->type),
1502 strna(sd_bus_message_get_sender(m)),
1503 strna(sd_bus_message_get_destination(m)),
1504 strna(sd_bus_message_get_path(m)),
1505 strna(sd_bus_message_get_interface(m)),
1506 strna(sd_bus_message_get_member(m)),
1507 BUS_MESSAGE_COOKIE(m),
1509 strna(m->error.message));
1514 static int dispatch_wqueue(sd_bus *bus) {
1518 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1520 while (bus->wqueue_size > 0) {
1522 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1526 /* Didn't do anything this time */
1528 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1529 /* Fully written. Let's drop the entry from
1532 * This isn't particularly optimized, but
1533 * well, this is supposed to be our worst-case
1534 * buffer only, and the socket buffer is
1535 * supposed to be our primary buffer, and if
1536 * it got full, then all bets are off
1539 bus->wqueue_size --;
1540 sd_bus_message_unref(bus->wqueue[0]);
1541 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1551 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1555 return bus_kernel_read_message(bus, hint_priority, priority);
1557 return bus_socket_read_message(bus);
1560 int bus_rqueue_make_room(sd_bus *bus) {
1563 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1566 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1572 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1577 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1579 /* Note that the priority logic is only available on kdbus,
1580 * where the rqueue is unused. We check the rqueue here
1581 * anyway, because it's simple... */
1584 if (bus->rqueue_size > 0) {
1585 /* Dispatch a queued message */
1587 *m = bus->rqueue[0];
1588 bus->rqueue_size --;
1589 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1593 /* Try to read a new message */
1594 r = bus_read_message(bus, hint_priority, priority);
1604 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1605 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1608 assert_return(bus, -EINVAL);
1609 assert_return(m, -EINVAL);
1610 assert_return(!bus_pid_changed(bus), -ECHILD);
1611 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1613 if (!BUS_IS_OPEN(bus->state))
1617 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1624 /* If the cookie number isn't kept, then we know that no reply
1626 if (!cookie && !m->sealed)
1627 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1629 r = bus_seal_message(bus, m, 0);
1633 /* Remarshall if we have to. This will possibly unref the
1634 * message and place a replacement in m */
1635 r = bus_remarshal_message(bus, &m);
1639 /* If this is a reply and no reply was requested, then let's
1640 * suppress this, if we can */
1641 if (m->dont_send && !cookie)
1644 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1647 r = bus_write_message(bus, m, hint_sync_call, &idx);
1649 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1650 bus_enter_closing(bus);
1655 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1656 /* Wasn't fully written. So let's remember how
1657 * much was written. Note that the first entry
1658 * of the wqueue array is always allocated so
1659 * that we always can remember how much was
1661 bus->wqueue[0] = sd_bus_message_ref(m);
1662 bus->wqueue_size = 1;
1666 /* Just append it to the queue. */
1668 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1671 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1674 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1678 *cookie = BUS_MESSAGE_COOKIE(m);
1683 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1684 return bus_send_internal(bus, m, cookie, false);
1687 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1690 assert_return(bus, -EINVAL);
1691 assert_return(m, -EINVAL);
1692 assert_return(!bus_pid_changed(bus), -ECHILD);
1694 if (!BUS_IS_OPEN(bus->state))
1697 if (!streq_ptr(m->destination, destination)) {
1702 r = sd_bus_message_set_destination(m, destination);
1707 return sd_bus_send(bus, m, cookie);
1710 static usec_t calc_elapse(uint64_t usec) {
1711 if (usec == (uint64_t) -1)
1714 return now(CLOCK_MONOTONIC) + usec;
1717 static int timeout_compare(const void *a, const void *b) {
1718 const struct reply_callback *x = a, *y = b;
1720 if (x->timeout != 0 && y->timeout == 0)
1723 if (x->timeout == 0 && y->timeout != 0)
1726 if (x->timeout < y->timeout)
1729 if (x->timeout > y->timeout)
1735 _public_ int sd_bus_call_async(
1739 sd_bus_message_handler_t callback,
1743 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1744 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1747 assert_return(bus, -EINVAL);
1748 assert_return(m, -EINVAL);
1749 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1750 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1751 assert_return(callback, -EINVAL);
1752 assert_return(!bus_pid_changed(bus), -ECHILD);
1753 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1755 if (!BUS_IS_OPEN(bus->state))
1758 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1762 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1766 r = bus_seal_message(bus, m, usec);
1770 r = bus_remarshal_message(bus, &m);
1774 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1778 s->reply_callback.callback = callback;
1780 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1781 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1783 s->reply_callback.cookie = 0;
1787 s->reply_callback.timeout = calc_elapse(m->timeout);
1788 if (s->reply_callback.timeout != 0) {
1789 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1791 s->reply_callback.timeout = 0;
1796 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1807 int bus_ensure_running(sd_bus *bus) {
1812 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1814 if (bus->state == BUS_RUNNING)
1818 r = sd_bus_process(bus, NULL);
1821 if (bus->state == BUS_RUNNING)
1826 r = sd_bus_wait(bus, (uint64_t) -1);
1832 _public_ int sd_bus_call(
1836 sd_bus_error *error,
1837 sd_bus_message **reply) {
1839 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1845 assert_return(bus, -EINVAL);
1846 assert_return(m, -EINVAL);
1847 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1848 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1849 assert_return(!bus_error_is_dirty(error), -EINVAL);
1850 assert_return(!bus_pid_changed(bus), -ECHILD);
1851 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1853 if (!BUS_IS_OPEN(bus->state))
1856 r = bus_ensure_running(bus);
1860 i = bus->rqueue_size;
1862 r = bus_seal_message(bus, m, usec);
1866 r = bus_remarshal_message(bus, &m);
1870 r = bus_send_internal(bus, m, &cookie, true);
1874 timeout = calc_elapse(m->timeout);
1879 while (i < bus->rqueue_size) {
1880 sd_bus_message *incoming = NULL;
1882 incoming = bus->rqueue[i];
1884 if (incoming->reply_cookie == cookie) {
1885 /* Found a match! */
1887 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1890 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1892 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1896 sd_bus_message_unref(incoming);
1901 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1903 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1904 r = sd_bus_error_copy(error, &incoming->error);
1908 sd_bus_message_unref(incoming);
1911 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1914 streq(bus->unique_name, incoming->sender)) {
1916 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1919 /* Our own message? Somebody is trying
1920 * to send its own client a message,
1921 * let's not dead-lock, let's fail
1924 sd_bus_message_unref(incoming);
1928 /* Try to read more, right-away */
1932 r = bus_read_message(bus, false, 0);
1934 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1935 bus_enter_closing(bus);
1947 n = now(CLOCK_MONOTONIC);
1953 left = (uint64_t) -1;
1955 r = bus_poll(bus, true, left);
1961 r = dispatch_wqueue(bus);
1963 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1964 bus_enter_closing(bus);
1973 _public_ int sd_bus_get_fd(sd_bus *bus) {
1975 assert_return(bus, -EINVAL);
1976 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1977 assert_return(!bus_pid_changed(bus), -ECHILD);
1979 return bus->input_fd;
1982 _public_ int sd_bus_get_events(sd_bus *bus) {
1985 assert_return(bus, -EINVAL);
1986 assert_return(!bus_pid_changed(bus), -ECHILD);
1988 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1991 if (bus->state == BUS_OPENING)
1993 else if (bus->state == BUS_AUTHENTICATING) {
1995 if (bus_socket_auth_needs_write(bus))
2000 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2001 if (bus->rqueue_size <= 0)
2003 if (bus->wqueue_size > 0)
2010 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2011 struct reply_callback *c;
2013 assert_return(bus, -EINVAL);
2014 assert_return(timeout_usec, -EINVAL);
2015 assert_return(!bus_pid_changed(bus), -ECHILD);
2017 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2020 if (bus->track_queue) {
2025 if (bus->state == BUS_CLOSING) {
2030 if (bus->state == BUS_AUTHENTICATING) {
2031 *timeout_usec = bus->auth_timeout;
2035 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2036 *timeout_usec = (uint64_t) -1;
2040 if (bus->rqueue_size > 0) {
2045 c = prioq_peek(bus->reply_callbacks_prioq);
2047 *timeout_usec = (uint64_t) -1;
2051 if (c->timeout == 0) {
2052 *timeout_usec = (uint64_t) -1;
2056 *timeout_usec = c->timeout;
2060 static int process_timeout(sd_bus *bus) {
2061 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2062 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2063 struct reply_callback *c;
2070 c = prioq_peek(bus->reply_callbacks_prioq);
2074 n = now(CLOCK_MONOTONIC);
2078 r = bus_message_new_synthetic_error(
2081 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2086 m->sender = "org.freedesktop.DBus";
2088 r = bus_seal_synthetic_message(bus, m);
2092 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2095 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2098 slot = container_of(c, sd_bus_slot, reply_callback);
2100 bus->iteration_counter ++;
2102 bus->current_message = m;
2103 bus->current_slot = sd_bus_slot_ref(slot);
2104 bus->current_handler = c->callback;
2105 bus->current_userdata = slot->userdata;
2106 r = c->callback(bus, m, slot->userdata, &error_buffer);
2107 bus->current_userdata = NULL;
2108 bus->current_handler = NULL;
2109 bus->current_slot = NULL;
2110 bus->current_message = NULL;
2112 if (slot->floating) {
2113 bus_slot_disconnect(slot);
2114 sd_bus_slot_unref(slot);
2117 sd_bus_slot_unref(slot);
2119 return bus_maybe_reply_error(m, r, &error_buffer);
2122 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2126 if (bus->state != BUS_HELLO)
2129 /* Let's make sure the first message on the bus is the HELLO
2130 * reply. But note that we don't actually parse the message
2131 * here (we leave that to the usual handling), we just verify
2132 * we don't let any earlier msg through. */
2134 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2135 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2138 if (m->reply_cookie != 1)
2144 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2145 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2146 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2147 struct reply_callback *c;
2154 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2155 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2158 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2161 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2164 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2170 slot = container_of(c, sd_bus_slot, reply_callback);
2172 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2174 /* If the reply contained a file descriptor which we
2175 * didn't want we pass an error instead. */
2177 r = bus_message_new_synthetic_error(
2180 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2185 r = bus_seal_synthetic_message(bus, synthetic_reply);
2189 m = synthetic_reply;
2191 r = sd_bus_message_rewind(m, true);
2196 if (c->timeout != 0) {
2197 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2201 bus->current_slot = sd_bus_slot_ref(slot);
2202 bus->current_handler = c->callback;
2203 bus->current_userdata = slot->userdata;
2204 r = c->callback(bus, m, slot->userdata, &error_buffer);
2205 bus->current_userdata = NULL;
2206 bus->current_handler = NULL;
2207 bus->current_slot = NULL;
2209 if (slot->floating) {
2210 bus_slot_disconnect(slot);
2211 sd_bus_slot_unref(slot);
2214 sd_bus_slot_unref(slot);
2216 return bus_maybe_reply_error(m, r, &error_buffer);
2219 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2220 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2221 struct filter_callback *l;
2228 bus->filter_callbacks_modified = false;
2230 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2233 if (bus->filter_callbacks_modified)
2236 /* Don't run this more than once per iteration */
2237 if (l->last_iteration == bus->iteration_counter)
2240 l->last_iteration = bus->iteration_counter;
2242 r = sd_bus_message_rewind(m, true);
2246 slot = container_of(l, sd_bus_slot, filter_callback);
2248 bus->current_slot = sd_bus_slot_ref(slot);
2249 bus->current_handler = l->callback;
2250 bus->current_userdata = slot->userdata;
2251 r = l->callback(bus, m, slot->userdata, &error_buffer);
2252 bus->current_userdata = NULL;
2253 bus->current_handler = NULL;
2254 bus->current_slot = sd_bus_slot_unref(slot);
2256 r = bus_maybe_reply_error(m, r, &error_buffer);
2262 } while (bus->filter_callbacks_modified);
2267 static int process_match(sd_bus *bus, sd_bus_message *m) {
2274 bus->match_callbacks_modified = false;
2276 r = bus_match_run(bus, &bus->match_callbacks, m);
2280 } while (bus->match_callbacks_modified);
2285 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2286 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2292 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2295 if (bus->manual_peer_interface)
2298 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2301 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2304 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2307 if (streq_ptr(m->member, "Ping"))
2308 r = sd_bus_message_new_method_return(m, &reply);
2309 else if (streq_ptr(m->member, "GetMachineId")) {
2313 r = sd_id128_get_machine(&id);
2317 r = sd_bus_message_new_method_return(m, &reply);
2321 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2323 r = sd_bus_message_new_method_errorf(
2325 SD_BUS_ERROR_UNKNOWN_METHOD,
2326 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2332 r = sd_bus_send(bus, reply, NULL);
2339 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2343 /* If we got a message with a file descriptor which we didn't
2344 * want to accept, then let's drop it. How can this even
2345 * happen? For example, when the kernel queues a message into
2346 * an activatable names's queue which allows fds, and then is
2347 * delivered to us later even though we ourselves did not
2350 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2356 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2359 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2360 return 1; /* just eat it up */
2362 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2365 static int process_message(sd_bus *bus, sd_bus_message *m) {
2371 bus->current_message = m;
2372 bus->iteration_counter++;
2374 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2375 bus_message_type_to_string(m->header->type),
2376 strna(sd_bus_message_get_sender(m)),
2377 strna(sd_bus_message_get_destination(m)),
2378 strna(sd_bus_message_get_path(m)),
2379 strna(sd_bus_message_get_interface(m)),
2380 strna(sd_bus_message_get_member(m)),
2381 BUS_MESSAGE_COOKIE(m),
2383 strna(m->error.message));
2385 r = process_hello(bus, m);
2389 r = process_reply(bus, m);
2393 r = process_fd_check(bus, m);
2397 r = process_filter(bus, m);
2401 r = process_match(bus, m);
2405 r = process_builtin(bus, m);
2409 r = bus_process_object(bus, m);
2412 bus->current_message = NULL;
2416 static int dispatch_track(sd_bus *bus) {
2419 if (!bus->track_queue)
2422 bus_track_dispatch(bus->track_queue);
2426 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2427 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2431 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2433 r = process_timeout(bus);
2437 r = dispatch_wqueue(bus);
2441 r = dispatch_track(bus);
2445 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2451 r = process_message(bus, m);
2456 r = sd_bus_message_rewind(m, true);
2465 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2467 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2468 strna(sd_bus_message_get_sender(m)),
2469 strna(sd_bus_message_get_path(m)),
2470 strna(sd_bus_message_get_interface(m)),
2471 strna(sd_bus_message_get_member(m)));
2473 r = sd_bus_reply_method_errorf(
2475 SD_BUS_ERROR_UNKNOWN_OBJECT,
2476 "Unknown object '%s'.", m->path);
2490 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2491 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2492 struct reply_callback *c;
2496 assert(bus->state == BUS_CLOSING);
2498 c = ordered_hashmap_first(bus->reply_callbacks);
2500 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2503 /* First, fail all outstanding method calls */
2504 r = bus_message_new_synthetic_error(
2507 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2512 r = bus_seal_synthetic_message(bus, m);
2516 if (c->timeout != 0) {
2517 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2521 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2524 slot = container_of(c, sd_bus_slot, reply_callback);
2526 bus->iteration_counter++;
2528 bus->current_message = m;
2529 bus->current_slot = sd_bus_slot_ref(slot);
2530 bus->current_handler = c->callback;
2531 bus->current_userdata = slot->userdata;
2532 r = c->callback(bus, m, slot->userdata, &error_buffer);
2533 bus->current_userdata = NULL;
2534 bus->current_handler = NULL;
2535 bus->current_slot = NULL;
2536 bus->current_message = NULL;
2538 if (slot->floating) {
2539 bus_slot_disconnect(slot);
2540 sd_bus_slot_unref(slot);
2543 sd_bus_slot_unref(slot);
2545 return bus_maybe_reply_error(m, r, &error_buffer);
2548 /* Then, synthesize a Disconnected message */
2549 r = sd_bus_message_new_signal(
2552 "/org/freedesktop/DBus/Local",
2553 "org.freedesktop.DBus.Local",
2558 m->sender = "org.freedesktop.DBus.Local";
2560 r = bus_seal_synthetic_message(bus, m);
2566 bus->current_message = m;
2567 bus->iteration_counter++;
2569 r = process_filter(bus, m);
2573 r = process_match(bus, m);
2585 bus->current_message = NULL;
2590 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2591 BUS_DONT_DESTROY(bus);
2594 /* Returns 0 when we didn't do anything. This should cause the
2595 * caller to invoke sd_bus_wait() before returning the next
2596 * time. Returns > 0 when we did something, which possibly
2597 * means *ret is filled in with an unprocessed message. */
2599 assert_return(bus, -EINVAL);
2600 assert_return(!bus_pid_changed(bus), -ECHILD);
2602 /* We don't allow recursively invoking sd_bus_process(). */
2603 assert_return(!bus->current_message, -EBUSY);
2604 assert(!bus->current_slot);
2606 switch (bus->state) {
2615 r = bus_socket_process_opening(bus);
2616 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2617 bus_enter_closing(bus);
2625 case BUS_AUTHENTICATING:
2626 r = bus_socket_process_authenticating(bus);
2627 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2628 bus_enter_closing(bus);
2640 r = process_running(bus, hint_priority, priority, ret);
2641 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2642 bus_enter_closing(bus);
2652 return process_closing(bus, ret);
2655 assert_not_reached("Unknown state");
2658 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2659 return bus_process_internal(bus, false, 0, ret);
2662 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2663 return bus_process_internal(bus, true, priority, ret);
2666 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2667 struct pollfd p[2] = {};
2670 usec_t m = USEC_INFINITY;
2674 if (bus->state == BUS_CLOSING)
2677 if (!BUS_IS_OPEN(bus->state))
2680 e = sd_bus_get_events(bus);
2685 /* The caller really needs some more data, he doesn't
2686 * care about what's already read, or any timeouts
2691 /* The caller wants to process if there's something to
2692 * process, but doesn't care otherwise */
2694 r = sd_bus_get_timeout(bus, &until);
2699 nw = now(CLOCK_MONOTONIC);
2700 m = until > nw ? until - nw : 0;
2704 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2707 p[0].fd = bus->input_fd;
2708 if (bus->output_fd == bus->input_fd) {
2712 p[0].events = e & POLLIN;
2713 p[1].fd = bus->output_fd;
2714 p[1].events = e & POLLOUT;
2718 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2722 return r > 0 ? 1 : 0;
2725 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2727 assert_return(bus, -EINVAL);
2728 assert_return(!bus_pid_changed(bus), -ECHILD);
2730 if (bus->state == BUS_CLOSING)
2733 if (!BUS_IS_OPEN(bus->state))
2736 if (bus->rqueue_size > 0)
2739 return bus_poll(bus, false, timeout_usec);
2742 _public_ int sd_bus_flush(sd_bus *bus) {
2745 assert_return(bus, -EINVAL);
2746 assert_return(!bus_pid_changed(bus), -ECHILD);
2748 if (bus->state == BUS_CLOSING)
2751 if (!BUS_IS_OPEN(bus->state))
2754 r = bus_ensure_running(bus);
2758 if (bus->wqueue_size <= 0)
2762 r = dispatch_wqueue(bus);
2764 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2765 bus_enter_closing(bus);
2772 if (bus->wqueue_size <= 0)
2775 r = bus_poll(bus, false, (uint64_t) -1);
2781 _public_ int sd_bus_add_filter(
2784 sd_bus_message_handler_t callback,
2789 assert_return(bus, -EINVAL);
2790 assert_return(callback, -EINVAL);
2791 assert_return(!bus_pid_changed(bus), -ECHILD);
2793 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2797 s->filter_callback.callback = callback;
2799 bus->filter_callbacks_modified = true;
2800 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2808 _public_ int sd_bus_add_match(
2812 sd_bus_message_handler_t callback,
2815 struct bus_match_component *components = NULL;
2816 unsigned n_components = 0;
2817 sd_bus_slot *s = NULL;
2820 assert_return(bus, -EINVAL);
2821 assert_return(match, -EINVAL);
2822 assert_return(!bus_pid_changed(bus), -ECHILD);
2824 r = bus_match_parse(match, &components, &n_components);
2828 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2834 s->match_callback.callback = callback;
2835 s->match_callback.cookie = ++bus->match_cookie;
2837 if (bus->bus_client) {
2839 if (!bus->is_kernel) {
2840 /* When this is not a kernel transport, we
2841 * store the original match string, so that we
2842 * can use it to remove the match again */
2844 s->match_callback.match_string = strdup(match);
2845 if (!s->match_callback.match_string) {
2851 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2856 bus->match_callbacks_modified = true;
2857 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2866 bus_match_parse_free(components, n_components);
2867 sd_bus_slot_unref(s);
2872 int bus_remove_match_by_string(
2875 sd_bus_message_handler_t callback,
2878 struct bus_match_component *components = NULL;
2879 unsigned n_components = 0;
2880 struct match_callback *c;
2883 assert_return(bus, -EINVAL);
2884 assert_return(match, -EINVAL);
2885 assert_return(!bus_pid_changed(bus), -ECHILD);
2887 r = bus_match_parse(match, &components, &n_components);
2891 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2895 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2898 bus_match_parse_free(components, n_components);
2903 bool bus_pid_changed(sd_bus *bus) {
2906 /* We don't support people creating a bus connection and
2907 * keeping it around over a fork(). Let's complain. */
2909 return bus->original_pid != getpid();
2912 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2913 sd_bus *bus = userdata;
2918 r = sd_bus_process(bus, NULL);
2925 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2926 sd_bus *bus = userdata;
2931 r = sd_bus_process(bus, NULL);
2938 static int prepare_callback(sd_event_source *s, void *userdata) {
2939 sd_bus *bus = userdata;
2946 e = sd_bus_get_events(bus);
2950 if (bus->output_fd != bus->input_fd) {
2952 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2956 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2960 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2965 r = sd_bus_get_timeout(bus, &until);
2971 j = sd_event_source_set_time(bus->time_event_source, until);
2976 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2983 static int quit_callback(sd_event_source *event, void *userdata) {
2984 sd_bus *bus = userdata;
2994 static int attach_io_events(sd_bus *bus) {
2999 if (bus->input_fd < 0)
3005 if (!bus->input_io_event_source) {
3006 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3010 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3014 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3018 r = sd_event_source_set_name(bus->input_io_event_source, "bus-input");
3020 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3025 if (bus->output_fd != bus->input_fd) {
3026 assert(bus->output_fd >= 0);
3028 if (!bus->output_io_event_source) {
3029 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3033 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3037 r = sd_event_source_set_name(bus->input_io_event_source, "bus-output");
3039 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3048 static void detach_io_events(sd_bus *bus) {
3051 if (bus->input_io_event_source) {
3052 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3053 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3056 if (bus->output_io_event_source) {
3057 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3058 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3062 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3065 assert_return(bus, -EINVAL);
3066 assert_return(!bus->event, -EBUSY);
3068 assert(!bus->input_io_event_source);
3069 assert(!bus->output_io_event_source);
3070 assert(!bus->time_event_source);
3073 bus->event = sd_event_ref(event);
3075 r = sd_event_default(&bus->event);
3080 bus->event_priority = priority;
3082 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3086 r = sd_event_source_set_priority(bus->time_event_source, priority);
3090 r = sd_event_source_set_name(bus->time_event_source, "bus-time");
3094 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3098 r = sd_event_source_set_name(bus->quit_event_source, "bus-exit");
3102 r = attach_io_events(bus);
3109 sd_bus_detach_event(bus);
3113 _public_ int sd_bus_detach_event(sd_bus *bus) {
3114 assert_return(bus, -EINVAL);
3119 detach_io_events(bus);
3121 if (bus->time_event_source) {
3122 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3123 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3126 if (bus->quit_event_source) {
3127 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3128 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3131 bus->event = sd_event_unref(bus->event);
3135 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3136 assert_return(bus, NULL);
3141 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3142 assert_return(bus, NULL);
3144 return bus->current_message;
3147 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3148 assert_return(bus, NULL);
3150 return bus->current_slot;
3153 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3154 assert_return(bus, NULL);
3156 return bus->current_handler;
3159 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3160 assert_return(bus, NULL);
3162 return bus->current_userdata;
3165 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3170 assert(default_bus);
3173 return !!*default_bus;
3176 *ret = sd_bus_ref(*default_bus);
3184 b->default_bus_ptr = default_bus;
3192 _public_ int sd_bus_default_system(sd_bus **ret) {
3193 static thread_local sd_bus *default_system_bus = NULL;
3195 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3198 _public_ int sd_bus_default_user(sd_bus **ret) {
3199 static thread_local sd_bus *default_user_bus = NULL;
3201 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3204 _public_ int sd_bus_default(sd_bus **ret) {
3208 /* Let's try our best to reuse another cached connection. If
3209 * the starter bus type is set, connect via our normal
3210 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3211 * we can share the connection with the user/system default
3214 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3216 if (streq(e, "system"))
3217 return sd_bus_default_system(ret);
3218 else if (STR_IN_SET(e, "user", "session"))
3219 return sd_bus_default_user(ret);
3222 /* No type is specified, so we have not other option than to
3223 * use the starter address if it is set. */
3225 e = secure_getenv("DBUS_STARTER_ADDRESS");
3227 static thread_local sd_bus *default_starter_bus = NULL;
3229 return bus_default(sd_bus_open, &default_starter_bus, ret);
3232 /* Finally, if nothing is set use the cached connection for
3233 * the right scope */
3235 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3236 return sd_bus_default_user(ret);
3238 return sd_bus_default_system(ret);
3241 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3242 assert_return(b, -EINVAL);
3243 assert_return(tid, -EINVAL);
3244 assert_return(!bus_pid_changed(b), -ECHILD);
3252 return sd_event_get_tid(b->event, tid);
3257 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3258 _cleanup_free_ char *e = NULL;
3261 assert_return(object_path_is_valid(prefix), -EINVAL);
3262 assert_return(external_id, -EINVAL);
3263 assert_return(ret_path, -EINVAL);
3265 e = bus_label_escape(external_id);
3269 ret = strjoin(prefix, "/", e, NULL);
3277 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3281 assert_return(object_path_is_valid(path), -EINVAL);
3282 assert_return(object_path_is_valid(prefix), -EINVAL);
3283 assert_return(external_id, -EINVAL);
3285 e = object_path_startswith(path, prefix);
3287 *external_id = NULL;
3291 ret = bus_label_unescape(e);
3299 _public_ int sd_bus_try_close(sd_bus *bus) {
3302 assert_return(bus, -EINVAL);
3303 assert_return(!bus_pid_changed(bus), -ECHILD);
3305 if (!bus->is_kernel)
3308 if (!BUS_IS_OPEN(bus->state))
3311 if (bus->rqueue_size > 0)
3314 if (bus->wqueue_size > 0)
3317 r = bus_kernel_try_close(bus);
3325 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3326 assert_return(bus, -EINVAL);
3327 assert_return(name, -EINVAL);
3328 assert_return(!bus_pid_changed(bus), -ECHILD);
3330 *name = bus->connection_name;
3334 int bus_get_root_path(sd_bus *bus) {
3337 if (bus->cgroup_root)
3340 r = cg_get_root_path(&bus->cgroup_root);
3342 bus->cgroup_root = strdup("/");
3343 if (!bus->cgroup_root)