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 hashmap_free_free(b->reply_callbacks);
143 prioq_free(b->reply_callbacks_prioq);
145 bus_match_free(&b->match_callbacks);
147 hashmap_free_free(b->vtable_methods);
148 hashmap_free_free(b->vtable_properties);
150 assert(hashmap_isempty(b->nodes));
151 hashmap_free(b->nodes);
153 bus_kernel_flush_memfd(b);
155 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
160 _public_ int sd_bus_new(sd_bus **ret) {
163 assert_return(ret, -EINVAL);
169 r->n_ref = REFCNT_INIT;
170 r->input_fd = r->output_fd = -1;
171 r->message_version = 1;
172 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
173 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
174 r->attach_flags |= KDBUS_ATTACH_NAMES;
175 r->original_pid = getpid();
177 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
179 /* We guarantee that wqueue always has space for at least one
181 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
190 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
193 assert_return(bus, -EINVAL);
194 assert_return(bus->state == BUS_UNSET, -EPERM);
195 assert_return(address, -EINVAL);
196 assert_return(!bus_pid_changed(bus), -ECHILD);
208 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
209 assert_return(bus, -EINVAL);
210 assert_return(bus->state == BUS_UNSET, -EPERM);
211 assert_return(input_fd >= 0, -EINVAL);
212 assert_return(output_fd >= 0, -EINVAL);
213 assert_return(!bus_pid_changed(bus), -ECHILD);
215 bus->input_fd = input_fd;
216 bus->output_fd = output_fd;
220 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
223 assert_return(bus, -EINVAL);
224 assert_return(bus->state == BUS_UNSET, -EPERM);
225 assert_return(path, -EINVAL);
226 assert_return(!strv_isempty(argv), -EINVAL);
227 assert_return(!bus_pid_changed(bus), -ECHILD);
239 free(bus->exec_path);
240 strv_free(bus->exec_argv);
248 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
249 assert_return(bus, -EINVAL);
250 assert_return(bus->state == BUS_UNSET, -EPERM);
251 assert_return(!bus_pid_changed(bus), -ECHILD);
253 bus->bus_client = !!b;
257 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
258 assert_return(bus, -EINVAL);
259 assert_return(bus->state == BUS_UNSET, -EPERM);
260 assert_return(!bus_pid_changed(bus), -ECHILD);
262 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
266 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
267 assert_return(bus, -EINVAL);
268 assert_return(bus->state == BUS_UNSET, -EPERM);
269 assert_return(!bus_pid_changed(bus), -ECHILD);
271 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
275 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
276 assert_return(bus, -EINVAL);
277 assert_return(bus->state == BUS_UNSET, -EPERM);
278 assert_return(!bus_pid_changed(bus), -ECHILD);
280 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
284 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
285 assert_return(bus, -EINVAL);
286 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
287 assert_return(bus->state == BUS_UNSET, -EPERM);
288 assert_return(!bus_pid_changed(bus), -ECHILD);
290 /* The well knowns we need unconditionally, so that matches can work */
291 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
293 return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags);
296 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
297 assert_return(bus, -EINVAL);
298 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
299 assert_return(bus->state == BUS_UNSET, -EPERM);
300 assert_return(!bus_pid_changed(bus), -ECHILD);
302 bus->is_server = !!b;
303 bus->server_id = server_id;
307 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
308 assert_return(bus, -EINVAL);
309 assert_return(bus->state == BUS_UNSET, -EPERM);
310 assert_return(!bus_pid_changed(bus), -ECHILD);
312 bus->anonymous_auth = !!b;
316 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
317 assert_return(bus, -EINVAL);
318 assert_return(bus->state == BUS_UNSET, -EPERM);
319 assert_return(!bus_pid_changed(bus), -ECHILD);
325 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
328 assert_return(bus, -EINVAL);
329 assert_return(name, -EINVAL);
330 assert_return(bus->state == BUS_UNSET, -EPERM);
331 assert_return(!bus_pid_changed(bus), -ECHILD);
337 free(bus->connection_name);
338 bus->connection_name = n;
343 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
348 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
351 r = sd_bus_message_get_errno(reply);
355 r = sd_bus_message_read(reply, "s", &s);
359 if (!service_name_is_valid(s) || s[0] != ':')
362 bus->unique_name = strdup(s);
363 if (!bus->unique_name)
366 if (bus->state == BUS_HELLO)
367 bus->state = BUS_RUNNING;
372 static int bus_send_hello(sd_bus *bus) {
373 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
378 if (!bus->bus_client || bus->is_kernel)
381 r = sd_bus_message_new_method_call(
384 "org.freedesktop.DBus",
385 "/org/freedesktop/DBus",
386 "org.freedesktop.DBus",
391 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
394 int bus_start_running(sd_bus *bus) {
397 if (bus->bus_client && !bus->is_kernel) {
398 bus->state = BUS_HELLO;
402 bus->state = BUS_RUNNING;
406 static int parse_address_key(const char **p, const char *key, char **value) {
407 size_t l, n = 0, allocated = 0;
417 if (strncmp(*p, key, l) != 0)
430 while (*a != ';' && *a != ',' && *a != 0) {
448 c = (char) ((x << 4) | y);
455 if (!GREEDY_REALLOC(r, allocated, n + 2))
479 static void skip_address_key(const char **p) {
483 *p += strcspn(*p, ",");
489 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
490 _cleanup_free_ char *path = NULL, *abstract = NULL;
499 while (**p != 0 && **p != ';') {
500 r = parse_address_key(p, "guid", guid);
506 r = parse_address_key(p, "path", &path);
512 r = parse_address_key(p, "abstract", &abstract);
521 if (!path && !abstract)
524 if (path && abstract)
529 if (l > sizeof(b->sockaddr.un.sun_path))
532 b->sockaddr.un.sun_family = AF_UNIX;
533 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
534 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
535 } else if (abstract) {
536 l = strlen(abstract);
537 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
540 b->sockaddr.un.sun_family = AF_UNIX;
541 b->sockaddr.un.sun_path[0] = 0;
542 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
543 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
549 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
550 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
552 struct addrinfo *result, hints = {
553 .ai_socktype = SOCK_STREAM,
554 .ai_flags = AI_ADDRCONFIG,
562 while (**p != 0 && **p != ';') {
563 r = parse_address_key(p, "guid", guid);
569 r = parse_address_key(p, "host", &host);
575 r = parse_address_key(p, "port", &port);
581 r = parse_address_key(p, "family", &family);
594 if (streq(family, "ipv4"))
595 hints.ai_family = AF_INET;
596 else if (streq(family, "ipv6"))
597 hints.ai_family = AF_INET6;
602 r = getaddrinfo(host, port, &hints, &result);
606 return -EADDRNOTAVAIL;
608 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
609 b->sockaddr_size = result->ai_addrlen;
611 freeaddrinfo(result);
616 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
618 unsigned n_argv = 0, j;
620 size_t allocated = 0;
628 while (**p != 0 && **p != ';') {
629 r = parse_address_key(p, "guid", guid);
635 r = parse_address_key(p, "path", &path);
641 if (startswith(*p, "argv")) {
645 ul = strtoul(*p + 4, (char**) p, 10);
646 if (errno > 0 || **p != '=' || ul > 256) {
654 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
662 r = parse_address_key(p, NULL, argv + ul);
677 /* Make sure there are no holes in the array, with the
678 * exception of argv[0] */
679 for (j = 1; j < n_argv; j++)
685 if (argv && argv[0] == NULL) {
686 argv[0] = strdup(path);
698 for (j = 0; j < n_argv; j++)
706 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
707 _cleanup_free_ char *path = NULL;
715 while (**p != 0 && **p != ';') {
716 r = parse_address_key(p, "guid", guid);
722 r = parse_address_key(p, "path", &path);
741 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
742 _cleanup_free_ char *machine = NULL;
750 while (**p != 0 && **p != ';') {
751 r = parse_address_key(p, "guid", guid);
757 r = parse_address_key(p, "machine", &machine);
769 if (!filename_is_safe(machine))
773 b->machine = machine;
776 b->sockaddr.un.sun_family = AF_UNIX;
777 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
778 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
783 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
784 _cleanup_free_ char *machine = NULL;
792 while (**p != 0 && **p != ';') {
793 r = parse_address_key(p, "guid", guid);
799 r = parse_address_key(p, "machine", &machine);
811 if (!filename_is_safe(machine))
815 b->machine = machine;
819 b->kernel = strdup("/dev/kdbus/0-system/bus");
826 static void bus_reset_parsed_address(sd_bus *b) {
830 b->sockaddr_size = 0;
831 strv_free(b->exec_argv);
835 b->server_id = SD_ID128_NULL;
842 static int bus_parse_next_address(sd_bus *b) {
843 _cleanup_free_ char *guid = NULL;
851 if (b->address[b->address_index] == 0)
854 bus_reset_parsed_address(b);
856 a = b->address + b->address_index;
865 if (startswith(a, "unix:")) {
868 r = parse_unix_address(b, &a, &guid);
873 } else if (startswith(a, "tcp:")) {
876 r = parse_tcp_address(b, &a, &guid);
882 } else if (startswith(a, "unixexec:")) {
885 r = parse_exec_address(b, &a, &guid);
891 } else if (startswith(a, "kernel:")) {
894 r = parse_kernel_address(b, &a, &guid);
899 } else if (startswith(a, "x-container-unix:")) {
902 r = parse_container_unix_address(b, &a, &guid);
907 } else if (startswith(a, "x-container-kernel:")) {
910 r = parse_container_kernel_address(b, &a, &guid);
923 r = sd_id128_from_string(guid, &b->server_id);
928 b->address_index = a - b->address;
932 static int bus_start_address(sd_bus *b) {
938 bool skipped = false;
943 r = bus_socket_exec(b);
944 else if (b->machine && b->kernel)
945 r = bus_container_connect_kernel(b);
946 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
947 r = bus_container_connect_socket(b);
949 r = bus_kernel_connect(b);
950 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
951 r = bus_socket_connect(b);
957 r = attach_io_events(b);
962 b->last_connect_error = -r;
965 r = bus_parse_next_address(b);
969 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
973 int bus_next_address(sd_bus *b) {
976 bus_reset_parsed_address(b);
977 return bus_start_address(b);
980 static int bus_start_fd(sd_bus *b) {
985 assert(b->input_fd >= 0);
986 assert(b->output_fd >= 0);
988 r = fd_nonblock(b->input_fd, true);
992 r = fd_cloexec(b->input_fd, true);
996 if (b->input_fd != b->output_fd) {
997 r = fd_nonblock(b->output_fd, true);
1001 r = fd_cloexec(b->output_fd, true);
1006 if (fstat(b->input_fd, &st) < 0)
1009 if (S_ISCHR(b->input_fd))
1010 return bus_kernel_take_fd(b);
1012 return bus_socket_take_fd(b);
1015 _public_ int sd_bus_start(sd_bus *bus) {
1018 assert_return(bus, -EINVAL);
1019 assert_return(bus->state == BUS_UNSET, -EPERM);
1020 assert_return(!bus_pid_changed(bus), -ECHILD);
1022 bus->state = BUS_OPENING;
1024 if (bus->is_server && bus->bus_client)
1027 if (bus->input_fd >= 0)
1028 r = bus_start_fd(bus);
1029 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1030 r = bus_start_address(bus);
1039 return bus_send_hello(bus);
1042 _public_ int sd_bus_open(sd_bus **ret) {
1047 assert_return(ret, -EINVAL);
1049 /* Let's connect to the starter bus if it is set, and
1050 * otherwise to the bus that is appropropriate for the scope
1051 * we are running in */
1053 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1055 if (streq(e, "system"))
1056 return sd_bus_open_system(ret);
1057 else if (STR_IN_SET(e, "session", "user"))
1058 return sd_bus_open_user(ret);
1061 e = secure_getenv("DBUS_STARTER_ADDRESS");
1063 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1064 return sd_bus_open_user(ret);
1066 return sd_bus_open_system(ret);
1073 r = sd_bus_set_address(b, e);
1077 b->bus_client = true;
1079 /* We don't know whether the bus is trusted or not, so better
1080 * be safe, and authenticate everything */
1082 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1084 r = sd_bus_start(b);
1096 int bus_set_address_system(sd_bus *b) {
1100 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1102 return sd_bus_set_address(b, e);
1104 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1107 _public_ int sd_bus_open_system(sd_bus **ret) {
1111 assert_return(ret, -EINVAL);
1117 r = bus_set_address_system(b);
1121 b->bus_client = true;
1122 b->is_system = true;
1124 /* Let's do per-method access control on the system bus. We
1125 * need the caller's UID and capability set for that. */
1127 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1129 r = sd_bus_start(b);
1141 int bus_set_address_user(sd_bus *b) {
1146 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1148 return sd_bus_set_address(b, e);
1150 e = secure_getenv("XDG_RUNTIME_DIR");
1152 _cleanup_free_ char *ee = NULL;
1154 ee = bus_address_escape(e);
1159 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1161 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1165 asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1167 return -ECONNREFUSED;
1177 _public_ int sd_bus_open_user(sd_bus **ret) {
1181 assert_return(ret, -EINVAL);
1187 r = bus_set_address_user(b);
1191 b->bus_client = true;
1194 /* We don't do any per-method access control on the user
1198 r = sd_bus_start(b);
1210 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1211 _cleanup_free_ char *e = NULL;
1212 char *m = NULL, *c = NULL;
1217 /* Let's see if we shall enter some container */
1218 m = strchr(host, ':');
1222 /* Let's make sure this is not a port of some kind,
1223 * and is a valid machine name. */
1224 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1227 /* Cut out the host part */
1228 t = strndupa(host, m - host - 1);
1229 e = bus_address_escape(t);
1233 c = strappenda(",argv4=--machine=", m);
1238 e = bus_address_escape(host);
1243 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1250 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1254 assert_return(host, -EINVAL);
1255 assert_return(ret, -EINVAL);
1257 r = sd_bus_new(&bus);
1261 r = bus_set_address_system_remote(bus, host);
1265 bus->bus_client = true;
1266 bus->trusted = false;
1268 r = sd_bus_start(bus);
1280 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1281 _cleanup_free_ char *e = NULL;
1286 e = bus_address_escape(machine);
1291 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1293 b->address = strjoin("x-container-unix:machine=", e, NULL);
1301 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1305 assert_return(machine, -EINVAL);
1306 assert_return(ret, -EINVAL);
1307 assert_return(filename_is_safe(machine), -EINVAL);
1309 r = sd_bus_new(&bus);
1313 r = bus_set_address_system_container(bus, machine);
1317 bus->bus_client = true;
1318 bus->trusted = false;
1320 r = sd_bus_start(bus);
1332 _public_ void sd_bus_close(sd_bus *bus) {
1336 if (bus->state == BUS_CLOSED)
1338 if (bus_pid_changed(bus))
1341 bus->state = BUS_CLOSED;
1343 sd_bus_detach_event(bus);
1345 /* Drop all queued messages so that they drop references to
1346 * the bus object and the bus may be freed */
1347 bus_reset_queues(bus);
1349 if (!bus->is_kernel)
1352 /* We'll leave the fd open in case this is a kernel bus, since
1353 * there might still be memblocks around that reference this
1354 * bus, and they might need to invoke the KDBUS_CMD_FREE
1355 * ioctl on the fd when they are freed. */
1358 static void bus_enter_closing(sd_bus *bus) {
1361 if (bus->state != BUS_OPENING &&
1362 bus->state != BUS_AUTHENTICATING &&
1363 bus->state != BUS_HELLO &&
1364 bus->state != BUS_RUNNING)
1367 bus->state = BUS_CLOSING;
1370 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1371 assert_return(bus, NULL);
1373 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1378 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1384 i = REFCNT_DEC(bus->n_ref);
1392 _public_ int sd_bus_is_open(sd_bus *bus) {
1394 assert_return(bus, -EINVAL);
1395 assert_return(!bus_pid_changed(bus), -ECHILD);
1397 return BUS_IS_OPEN(bus->state);
1400 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1403 assert_return(bus, -EINVAL);
1404 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1405 assert_return(!bus_pid_changed(bus), -ECHILD);
1407 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1410 if (type == SD_BUS_TYPE_UNIX_FD) {
1411 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1414 r = bus_ensure_running(bus);
1418 return bus->can_fds;
1421 return bus_type_is_valid(type);
1424 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1427 assert_return(bus, -EINVAL);
1428 assert_return(server_id, -EINVAL);
1429 assert_return(!bus_pid_changed(bus), -ECHILD);
1431 r = bus_ensure_running(bus);
1435 *server_id = bus->server_id;
1439 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1444 /* If we copy the same message to multiple
1445 * destinations, avoid using the same cookie
1447 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1452 timeout = BUS_DEFAULT_TIMEOUT;
1454 return bus_message_seal(m, ++b->cookie, timeout);
1457 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1460 /* Do packet version and endianness already match? */
1461 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1462 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1465 /* No? Then remarshal! */
1466 return bus_message_remarshal(b, m);
1469 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1473 /* The bus specification says the serial number cannot be 0,
1474 * hence let's fill something in for synthetic messages. Since
1475 * synthetic messages might have a fake sender and we don't
1476 * want to interfere with the real sender's serial numbers we
1477 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1478 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1479 * even though kdbus can do 64bit. */
1481 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1484 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1491 r = bus_kernel_write_message(bus, m, hint_sync_call);
1493 r = bus_socket_write_message(bus, m, idx);
1498 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1499 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1500 bus_message_type_to_string(m->header->type),
1501 strna(sd_bus_message_get_sender(m)),
1502 strna(sd_bus_message_get_destination(m)),
1503 strna(sd_bus_message_get_path(m)),
1504 strna(sd_bus_message_get_interface(m)),
1505 strna(sd_bus_message_get_member(m)),
1506 BUS_MESSAGE_COOKIE(m),
1508 strna(m->error.message));
1513 static int dispatch_wqueue(sd_bus *bus) {
1517 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1519 while (bus->wqueue_size > 0) {
1521 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1525 /* Didn't do anything this time */
1527 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1528 /* Fully written. Let's drop the entry from
1531 * This isn't particularly optimized, but
1532 * well, this is supposed to be our worst-case
1533 * buffer only, and the socket buffer is
1534 * supposed to be our primary buffer, and if
1535 * it got full, then all bets are off
1538 bus->wqueue_size --;
1539 sd_bus_message_unref(bus->wqueue[0]);
1540 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1550 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1554 return bus_kernel_read_message(bus, hint_priority, priority);
1556 return bus_socket_read_message(bus);
1559 int bus_rqueue_make_room(sd_bus *bus) {
1562 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1565 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1571 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1576 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1578 /* Note that the priority logic is only available on kdbus,
1579 * where the rqueue is unused. We check the rqueue here
1580 * anyway, because it's simple... */
1583 if (bus->rqueue_size > 0) {
1584 /* Dispatch a queued message */
1586 *m = bus->rqueue[0];
1587 bus->rqueue_size --;
1588 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1592 /* Try to read a new message */
1593 r = bus_read_message(bus, hint_priority, priority);
1603 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1604 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1607 assert_return(bus, -EINVAL);
1608 assert_return(m, -EINVAL);
1609 assert_return(!bus_pid_changed(bus), -ECHILD);
1610 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1612 if (!BUS_IS_OPEN(bus->state))
1616 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1623 /* If the cookie number isn't kept, then we know that no reply
1625 if (!cookie && !m->sealed)
1626 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1628 r = bus_seal_message(bus, m, 0);
1632 /* Remarshall if we have to. This will possibly unref the
1633 * message and place a replacement in m */
1634 r = bus_remarshal_message(bus, &m);
1638 /* If this is a reply and no reply was requested, then let's
1639 * suppress this, if we can */
1640 if (m->dont_send && !cookie)
1643 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1646 r = bus_write_message(bus, m, hint_sync_call, &idx);
1648 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1649 bus_enter_closing(bus);
1654 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1655 /* Wasn't fully written. So let's remember how
1656 * much was written. Note that the first entry
1657 * of the wqueue array is always allocated so
1658 * that we always can remember how much was
1660 bus->wqueue[0] = sd_bus_message_ref(m);
1661 bus->wqueue_size = 1;
1665 /* Just append it to the queue. */
1667 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1670 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1673 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1677 *cookie = BUS_MESSAGE_COOKIE(m);
1682 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1683 return bus_send_internal(bus, m, cookie, false);
1686 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1689 assert_return(bus, -EINVAL);
1690 assert_return(m, -EINVAL);
1691 assert_return(!bus_pid_changed(bus), -ECHILD);
1693 if (!BUS_IS_OPEN(bus->state))
1696 if (!streq_ptr(m->destination, destination)) {
1701 r = sd_bus_message_set_destination(m, destination);
1706 return sd_bus_send(bus, m, cookie);
1709 static usec_t calc_elapse(uint64_t usec) {
1710 if (usec == (uint64_t) -1)
1713 return now(CLOCK_MONOTONIC) + usec;
1716 static int timeout_compare(const void *a, const void *b) {
1717 const struct reply_callback *x = a, *y = b;
1719 if (x->timeout != 0 && y->timeout == 0)
1722 if (x->timeout == 0 && y->timeout != 0)
1725 if (x->timeout < y->timeout)
1728 if (x->timeout > y->timeout)
1734 _public_ int sd_bus_call_async(
1738 sd_bus_message_handler_t callback,
1742 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1743 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1746 assert_return(bus, -EINVAL);
1747 assert_return(m, -EINVAL);
1748 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1749 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1750 assert_return(callback, -EINVAL);
1751 assert_return(!bus_pid_changed(bus), -ECHILD);
1752 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1754 if (!BUS_IS_OPEN(bus->state))
1757 r = hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1761 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1765 r = bus_seal_message(bus, m, usec);
1769 r = bus_remarshal_message(bus, &m);
1773 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1777 s->reply_callback.callback = callback;
1779 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1780 r = hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1782 s->reply_callback.cookie = 0;
1786 s->reply_callback.timeout = calc_elapse(m->timeout);
1787 if (s->reply_callback.timeout != 0) {
1788 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1790 s->reply_callback.timeout = 0;
1795 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1806 int bus_ensure_running(sd_bus *bus) {
1811 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1813 if (bus->state == BUS_RUNNING)
1817 r = sd_bus_process(bus, NULL);
1820 if (bus->state == BUS_RUNNING)
1825 r = sd_bus_wait(bus, (uint64_t) -1);
1831 _public_ int sd_bus_call(
1835 sd_bus_error *error,
1836 sd_bus_message **reply) {
1838 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1844 assert_return(bus, -EINVAL);
1845 assert_return(m, -EINVAL);
1846 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1847 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1848 assert_return(!bus_error_is_dirty(error), -EINVAL);
1849 assert_return(!bus_pid_changed(bus), -ECHILD);
1850 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1852 if (!BUS_IS_OPEN(bus->state))
1855 r = bus_ensure_running(bus);
1859 i = bus->rqueue_size;
1861 r = bus_seal_message(bus, m, usec);
1865 r = bus_remarshal_message(bus, &m);
1869 r = bus_send_internal(bus, m, &cookie, true);
1873 timeout = calc_elapse(m->timeout);
1878 while (i < bus->rqueue_size) {
1879 sd_bus_message *incoming = NULL;
1881 incoming = bus->rqueue[i];
1883 if (incoming->reply_cookie == cookie) {
1884 /* Found a match! */
1886 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1889 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1891 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1895 sd_bus_message_unref(incoming);
1900 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1902 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1903 r = sd_bus_error_copy(error, &incoming->error);
1907 sd_bus_message_unref(incoming);
1910 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1913 streq(bus->unique_name, incoming->sender)) {
1915 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1918 /* Our own message? Somebody is trying
1919 * to send its own client a message,
1920 * let's not dead-lock, let's fail
1923 sd_bus_message_unref(incoming);
1927 /* Try to read more, right-away */
1931 r = bus_read_message(bus, false, 0);
1933 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1934 bus_enter_closing(bus);
1946 n = now(CLOCK_MONOTONIC);
1952 left = (uint64_t) -1;
1954 r = bus_poll(bus, true, left);
1960 r = dispatch_wqueue(bus);
1962 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1963 bus_enter_closing(bus);
1972 _public_ int sd_bus_get_fd(sd_bus *bus) {
1974 assert_return(bus, -EINVAL);
1975 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1976 assert_return(!bus_pid_changed(bus), -ECHILD);
1978 return bus->input_fd;
1981 _public_ int sd_bus_get_events(sd_bus *bus) {
1984 assert_return(bus, -EINVAL);
1985 assert_return(!bus_pid_changed(bus), -ECHILD);
1987 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1990 if (bus->state == BUS_OPENING)
1992 else if (bus->state == BUS_AUTHENTICATING) {
1994 if (bus_socket_auth_needs_write(bus))
1999 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2000 if (bus->rqueue_size <= 0)
2002 if (bus->wqueue_size > 0)
2009 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2010 struct reply_callback *c;
2012 assert_return(bus, -EINVAL);
2013 assert_return(timeout_usec, -EINVAL);
2014 assert_return(!bus_pid_changed(bus), -ECHILD);
2016 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2019 if (bus->track_queue) {
2024 if (bus->state == BUS_CLOSING) {
2029 if (bus->state == BUS_AUTHENTICATING) {
2030 *timeout_usec = bus->auth_timeout;
2034 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2035 *timeout_usec = (uint64_t) -1;
2039 if (bus->rqueue_size > 0) {
2044 c = prioq_peek(bus->reply_callbacks_prioq);
2046 *timeout_usec = (uint64_t) -1;
2050 if (c->timeout == 0) {
2051 *timeout_usec = (uint64_t) -1;
2055 *timeout_usec = c->timeout;
2059 static int process_timeout(sd_bus *bus) {
2060 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2061 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2062 struct reply_callback *c;
2069 c = prioq_peek(bus->reply_callbacks_prioq);
2073 n = now(CLOCK_MONOTONIC);
2077 r = bus_message_new_synthetic_error(
2080 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2085 m->sender = "org.freedesktop.DBus";
2087 r = bus_seal_synthetic_message(bus, m);
2091 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2094 hashmap_remove(bus->reply_callbacks, &c->cookie);
2097 slot = container_of(c, sd_bus_slot, reply_callback);
2099 bus->iteration_counter ++;
2101 bus->current_message = m;
2102 bus->current_slot = sd_bus_slot_ref(slot);
2103 bus->current_handler = c->callback;
2104 bus->current_userdata = slot->userdata;
2105 r = c->callback(bus, m, slot->userdata, &error_buffer);
2106 bus->current_userdata = NULL;
2107 bus->current_handler = NULL;
2108 bus->current_slot = NULL;
2109 bus->current_message = NULL;
2111 if (slot->floating) {
2112 bus_slot_disconnect(slot);
2113 sd_bus_slot_unref(slot);
2116 sd_bus_slot_unref(slot);
2118 return bus_maybe_reply_error(m, r, &error_buffer);
2121 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2125 if (bus->state != BUS_HELLO)
2128 /* Let's make sure the first message on the bus is the HELLO
2129 * reply. But note that we don't actually parse the message
2130 * here (we leave that to the usual handling), we just verify
2131 * we don't let any earlier msg through. */
2133 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2134 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2137 if (m->reply_cookie != 1)
2143 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2144 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2145 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2146 struct reply_callback *c;
2153 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2154 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2157 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2160 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2163 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2169 slot = container_of(c, sd_bus_slot, reply_callback);
2171 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2173 /* If the reply contained a file descriptor which we
2174 * didn't want we pass an error instead. */
2176 r = bus_message_new_synthetic_error(
2179 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2184 r = bus_seal_synthetic_message(bus, synthetic_reply);
2188 m = synthetic_reply;
2190 r = sd_bus_message_rewind(m, true);
2195 if (c->timeout != 0) {
2196 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2200 bus->current_slot = sd_bus_slot_ref(slot);
2201 bus->current_handler = c->callback;
2202 bus->current_userdata = slot->userdata;
2203 r = c->callback(bus, m, slot->userdata, &error_buffer);
2204 bus->current_userdata = NULL;
2205 bus->current_handler = NULL;
2206 bus->current_slot = NULL;
2208 if (slot->floating) {
2209 bus_slot_disconnect(slot);
2210 sd_bus_slot_unref(slot);
2213 sd_bus_slot_unref(slot);
2215 return bus_maybe_reply_error(m, r, &error_buffer);
2218 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2219 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2220 struct filter_callback *l;
2227 bus->filter_callbacks_modified = false;
2229 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2232 if (bus->filter_callbacks_modified)
2235 /* Don't run this more than once per iteration */
2236 if (l->last_iteration == bus->iteration_counter)
2239 l->last_iteration = bus->iteration_counter;
2241 r = sd_bus_message_rewind(m, true);
2245 slot = container_of(l, sd_bus_slot, filter_callback);
2247 bus->current_slot = sd_bus_slot_ref(slot);
2248 bus->current_handler = l->callback;
2249 bus->current_userdata = slot->userdata;
2250 r = l->callback(bus, m, slot->userdata, &error_buffer);
2251 bus->current_userdata = NULL;
2252 bus->current_handler = NULL;
2253 bus->current_slot = sd_bus_slot_unref(slot);
2255 r = bus_maybe_reply_error(m, r, &error_buffer);
2261 } while (bus->filter_callbacks_modified);
2266 static int process_match(sd_bus *bus, sd_bus_message *m) {
2273 bus->match_callbacks_modified = false;
2275 r = bus_match_run(bus, &bus->match_callbacks, m);
2279 } while (bus->match_callbacks_modified);
2284 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2285 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2291 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2294 if (bus->manual_peer_interface)
2297 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2300 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2303 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2306 if (streq_ptr(m->member, "Ping"))
2307 r = sd_bus_message_new_method_return(m, &reply);
2308 else if (streq_ptr(m->member, "GetMachineId")) {
2312 r = sd_id128_get_machine(&id);
2316 r = sd_bus_message_new_method_return(m, &reply);
2320 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2322 r = sd_bus_message_new_method_errorf(
2324 SD_BUS_ERROR_UNKNOWN_METHOD,
2325 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2331 r = sd_bus_send(bus, reply, NULL);
2338 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2342 /* If we got a message with a file descriptor which we didn't
2343 * want to accept, then let's drop it. How can this even
2344 * happen? For example, when the kernel queues a message into
2345 * an activatable names's queue which allows fds, and then is
2346 * delivered to us later even though we ourselves did not
2349 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2355 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2358 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2359 return 1; /* just eat it up */
2361 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2364 static int process_message(sd_bus *bus, sd_bus_message *m) {
2370 bus->current_message = m;
2371 bus->iteration_counter++;
2373 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2374 bus_message_type_to_string(m->header->type),
2375 strna(sd_bus_message_get_sender(m)),
2376 strna(sd_bus_message_get_destination(m)),
2377 strna(sd_bus_message_get_path(m)),
2378 strna(sd_bus_message_get_interface(m)),
2379 strna(sd_bus_message_get_member(m)),
2380 BUS_MESSAGE_COOKIE(m),
2382 strna(m->error.message));
2384 r = process_hello(bus, m);
2388 r = process_reply(bus, m);
2392 r = process_fd_check(bus, m);
2396 r = process_filter(bus, m);
2400 r = process_match(bus, m);
2404 r = process_builtin(bus, m);
2408 r = bus_process_object(bus, m);
2411 bus->current_message = NULL;
2415 static int dispatch_track(sd_bus *bus) {
2418 if (!bus->track_queue)
2421 bus_track_dispatch(bus->track_queue);
2425 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2426 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2430 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2432 r = process_timeout(bus);
2436 r = dispatch_wqueue(bus);
2440 r = dispatch_track(bus);
2444 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2450 r = process_message(bus, m);
2455 r = sd_bus_message_rewind(m, true);
2464 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2466 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2467 strna(sd_bus_message_get_sender(m)),
2468 strna(sd_bus_message_get_path(m)),
2469 strna(sd_bus_message_get_interface(m)),
2470 strna(sd_bus_message_get_member(m)));
2472 r = sd_bus_reply_method_errorf(
2474 SD_BUS_ERROR_UNKNOWN_OBJECT,
2475 "Unknown object '%s'.", m->path);
2489 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2490 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2491 struct reply_callback *c;
2495 assert(bus->state == BUS_CLOSING);
2497 c = hashmap_first(bus->reply_callbacks);
2499 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2502 /* First, fail all outstanding method calls */
2503 r = bus_message_new_synthetic_error(
2506 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2511 r = bus_seal_synthetic_message(bus, m);
2515 if (c->timeout != 0) {
2516 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2520 hashmap_remove(bus->reply_callbacks, &c->cookie);
2523 slot = container_of(c, sd_bus_slot, reply_callback);
2525 bus->iteration_counter++;
2527 bus->current_message = m;
2528 bus->current_slot = sd_bus_slot_ref(slot);
2529 bus->current_handler = c->callback;
2530 bus->current_userdata = slot->userdata;
2531 r = c->callback(bus, m, slot->userdata, &error_buffer);
2532 bus->current_userdata = NULL;
2533 bus->current_handler = NULL;
2534 bus->current_slot = NULL;
2535 bus->current_message = NULL;
2537 if (slot->floating) {
2538 bus_slot_disconnect(slot);
2539 sd_bus_slot_unref(slot);
2542 sd_bus_slot_unref(slot);
2544 return bus_maybe_reply_error(m, r, &error_buffer);
2547 /* Then, synthesize a Disconnected message */
2548 r = sd_bus_message_new_signal(
2551 "/org/freedesktop/DBus/Local",
2552 "org.freedesktop.DBus.Local",
2557 m->sender = "org.freedesktop.DBus.Local";
2559 r = bus_seal_synthetic_message(bus, m);
2565 bus->current_message = m;
2566 bus->iteration_counter++;
2568 r = process_filter(bus, m);
2572 r = process_match(bus, m);
2584 bus->current_message = NULL;
2589 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2590 BUS_DONT_DESTROY(bus);
2593 /* Returns 0 when we didn't do anything. This should cause the
2594 * caller to invoke sd_bus_wait() before returning the next
2595 * time. Returns > 0 when we did something, which possibly
2596 * means *ret is filled in with an unprocessed message. */
2598 assert_return(bus, -EINVAL);
2599 assert_return(!bus_pid_changed(bus), -ECHILD);
2601 /* We don't allow recursively invoking sd_bus_process(). */
2602 assert_return(!bus->current_message, -EBUSY);
2603 assert(!bus->current_slot);
2605 switch (bus->state) {
2614 r = bus_socket_process_opening(bus);
2615 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2616 bus_enter_closing(bus);
2624 case BUS_AUTHENTICATING:
2625 r = bus_socket_process_authenticating(bus);
2626 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2627 bus_enter_closing(bus);
2639 r = process_running(bus, hint_priority, priority, ret);
2640 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2641 bus_enter_closing(bus);
2651 return process_closing(bus, ret);
2654 assert_not_reached("Unknown state");
2657 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2658 return bus_process_internal(bus, false, 0, ret);
2661 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2662 return bus_process_internal(bus, true, priority, ret);
2665 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2666 struct pollfd p[2] = {};
2669 usec_t m = USEC_INFINITY;
2673 if (bus->state == BUS_CLOSING)
2676 if (!BUS_IS_OPEN(bus->state))
2679 e = sd_bus_get_events(bus);
2684 /* The caller really needs some more data, he doesn't
2685 * care about what's already read, or any timeouts
2690 /* The caller wants to process if there's something to
2691 * process, but doesn't care otherwise */
2693 r = sd_bus_get_timeout(bus, &until);
2698 nw = now(CLOCK_MONOTONIC);
2699 m = until > nw ? until - nw : 0;
2703 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2706 p[0].fd = bus->input_fd;
2707 if (bus->output_fd == bus->input_fd) {
2711 p[0].events = e & POLLIN;
2712 p[1].fd = bus->output_fd;
2713 p[1].events = e & POLLOUT;
2717 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2721 return r > 0 ? 1 : 0;
2724 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2726 assert_return(bus, -EINVAL);
2727 assert_return(!bus_pid_changed(bus), -ECHILD);
2729 if (bus->state == BUS_CLOSING)
2732 if (!BUS_IS_OPEN(bus->state))
2735 if (bus->rqueue_size > 0)
2738 return bus_poll(bus, false, timeout_usec);
2741 _public_ int sd_bus_flush(sd_bus *bus) {
2744 assert_return(bus, -EINVAL);
2745 assert_return(!bus_pid_changed(bus), -ECHILD);
2747 if (bus->state == BUS_CLOSING)
2750 if (!BUS_IS_OPEN(bus->state))
2753 r = bus_ensure_running(bus);
2757 if (bus->wqueue_size <= 0)
2761 r = dispatch_wqueue(bus);
2763 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2764 bus_enter_closing(bus);
2771 if (bus->wqueue_size <= 0)
2774 r = bus_poll(bus, false, (uint64_t) -1);
2780 _public_ int sd_bus_add_filter(
2783 sd_bus_message_handler_t callback,
2788 assert_return(bus, -EINVAL);
2789 assert_return(callback, -EINVAL);
2790 assert_return(!bus_pid_changed(bus), -ECHILD);
2792 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2796 s->filter_callback.callback = callback;
2798 bus->filter_callbacks_modified = true;
2799 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2807 _public_ int sd_bus_add_match(
2811 sd_bus_message_handler_t callback,
2814 struct bus_match_component *components = NULL;
2815 unsigned n_components = 0;
2816 sd_bus_slot *s = NULL;
2819 assert_return(bus, -EINVAL);
2820 assert_return(match, -EINVAL);
2821 assert_return(!bus_pid_changed(bus), -ECHILD);
2823 r = bus_match_parse(match, &components, &n_components);
2827 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2833 s->match_callback.callback = callback;
2834 s->match_callback.cookie = ++bus->match_cookie;
2836 if (bus->bus_client) {
2838 if (!bus->is_kernel) {
2839 /* When this is not a kernel transport, we
2840 * store the original match string, so that we
2841 * can use it to remove the match again */
2843 s->match_callback.match_string = strdup(match);
2844 if (!s->match_callback.match_string) {
2850 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2855 bus->match_callbacks_modified = true;
2856 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2865 bus_match_parse_free(components, n_components);
2866 sd_bus_slot_unref(s);
2871 int bus_remove_match_by_string(
2874 sd_bus_message_handler_t callback,
2877 struct bus_match_component *components = NULL;
2878 unsigned n_components = 0;
2879 struct match_callback *c;
2882 assert_return(bus, -EINVAL);
2883 assert_return(match, -EINVAL);
2884 assert_return(!bus_pid_changed(bus), -ECHILD);
2886 r = bus_match_parse(match, &components, &n_components);
2890 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2894 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2897 bus_match_parse_free(components, n_components);
2902 bool bus_pid_changed(sd_bus *bus) {
2905 /* We don't support people creating a bus connection and
2906 * keeping it around over a fork(). Let's complain. */
2908 return bus->original_pid != getpid();
2911 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2912 sd_bus *bus = userdata;
2917 r = sd_bus_process(bus, NULL);
2924 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2925 sd_bus *bus = userdata;
2930 r = sd_bus_process(bus, NULL);
2937 static int prepare_callback(sd_event_source *s, void *userdata) {
2938 sd_bus *bus = userdata;
2945 e = sd_bus_get_events(bus);
2949 if (bus->output_fd != bus->input_fd) {
2951 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2955 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2959 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2964 r = sd_bus_get_timeout(bus, &until);
2970 j = sd_event_source_set_time(bus->time_event_source, until);
2975 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2982 static int quit_callback(sd_event_source *event, void *userdata) {
2983 sd_bus *bus = userdata;
2993 static int attach_io_events(sd_bus *bus) {
2998 if (bus->input_fd < 0)
3004 if (!bus->input_io_event_source) {
3005 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3009 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3013 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3017 r = sd_event_source_set_name(bus->input_io_event_source, "bus-input");
3019 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3024 if (bus->output_fd != bus->input_fd) {
3025 assert(bus->output_fd >= 0);
3027 if (!bus->output_io_event_source) {
3028 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3032 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3036 r = sd_event_source_set_name(bus->input_io_event_source, "bus-output");
3038 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3047 static void detach_io_events(sd_bus *bus) {
3050 if (bus->input_io_event_source) {
3051 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3052 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3055 if (bus->output_io_event_source) {
3056 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3057 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3061 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3064 assert_return(bus, -EINVAL);
3065 assert_return(!bus->event, -EBUSY);
3067 assert(!bus->input_io_event_source);
3068 assert(!bus->output_io_event_source);
3069 assert(!bus->time_event_source);
3072 bus->event = sd_event_ref(event);
3074 r = sd_event_default(&bus->event);
3079 bus->event_priority = priority;
3081 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3085 r = sd_event_source_set_priority(bus->time_event_source, priority);
3089 r = sd_event_source_set_name(bus->time_event_source, "bus-time");
3093 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3097 r = sd_event_source_set_name(bus->quit_event_source, "bus-exit");
3101 r = attach_io_events(bus);
3108 sd_bus_detach_event(bus);
3112 _public_ int sd_bus_detach_event(sd_bus *bus) {
3113 assert_return(bus, -EINVAL);
3118 detach_io_events(bus);
3120 if (bus->time_event_source) {
3121 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3122 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3125 if (bus->quit_event_source) {
3126 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3127 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3130 bus->event = sd_event_unref(bus->event);
3134 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3135 assert_return(bus, NULL);
3140 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3141 assert_return(bus, NULL);
3143 return bus->current_message;
3146 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3147 assert_return(bus, NULL);
3149 return bus->current_slot;
3152 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3153 assert_return(bus, NULL);
3155 return bus->current_handler;
3158 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3159 assert_return(bus, NULL);
3161 return bus->current_userdata;
3164 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3169 assert(default_bus);
3172 return !!*default_bus;
3175 *ret = sd_bus_ref(*default_bus);
3183 b->default_bus_ptr = default_bus;
3191 _public_ int sd_bus_default_system(sd_bus **ret) {
3192 static thread_local sd_bus *default_system_bus = NULL;
3194 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3197 _public_ int sd_bus_default_user(sd_bus **ret) {
3198 static thread_local sd_bus *default_user_bus = NULL;
3200 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3203 _public_ int sd_bus_default(sd_bus **ret) {
3207 /* Let's try our best to reuse another cached connection. If
3208 * the starter bus type is set, connect via our normal
3209 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3210 * we can share the connection with the user/system default
3213 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3215 if (streq(e, "system"))
3216 return sd_bus_default_system(ret);
3217 else if (STR_IN_SET(e, "user", "session"))
3218 return sd_bus_default_user(ret);
3221 /* No type is specified, so we have not other option than to
3222 * use the starter address if it is set. */
3224 e = secure_getenv("DBUS_STARTER_ADDRESS");
3226 static thread_local sd_bus *default_starter_bus = NULL;
3228 return bus_default(sd_bus_open, &default_starter_bus, ret);
3231 /* Finally, if nothing is set use the cached connection for
3232 * the right scope */
3234 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3235 return sd_bus_default_user(ret);
3237 return sd_bus_default_system(ret);
3240 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3241 assert_return(b, -EINVAL);
3242 assert_return(tid, -EINVAL);
3243 assert_return(!bus_pid_changed(b), -ECHILD);
3251 return sd_event_get_tid(b->event, tid);
3256 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3257 _cleanup_free_ char *e = NULL;
3260 assert_return(object_path_is_valid(prefix), -EINVAL);
3261 assert_return(external_id, -EINVAL);
3262 assert_return(ret_path, -EINVAL);
3264 e = bus_label_escape(external_id);
3268 ret = strjoin(prefix, "/", e, NULL);
3276 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3280 assert_return(object_path_is_valid(path), -EINVAL);
3281 assert_return(object_path_is_valid(prefix), -EINVAL);
3282 assert_return(external_id, -EINVAL);
3284 e = object_path_startswith(path, prefix);
3286 *external_id = NULL;
3290 ret = bus_label_unescape(e);
3298 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3303 assert_return(bus, -EINVAL);
3304 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3305 assert_return(ret, -EINVAL);
3306 assert_return(!bus_pid_changed(bus), -ECHILD);
3311 if (!BUS_IS_OPEN(bus->state))
3314 if (!bus->ucred_valid && !isempty(bus->label))
3317 c = bus_creds_new();
3321 if (bus->ucred_valid) {
3322 pid = c->pid = bus->ucred.pid;
3323 c->uid = bus->ucred.uid;
3324 c->gid = bus->ucred.gid;
3326 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3329 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3330 c->label = strdup(bus->label);
3332 sd_bus_creds_unref(c);
3336 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3339 r = bus_creds_add_more(c, mask, pid, 0);
3341 sd_bus_creds_unref(c);
3349 _public_ int sd_bus_try_close(sd_bus *bus) {
3352 assert_return(bus, -EINVAL);
3353 assert_return(!bus_pid_changed(bus), -ECHILD);
3355 if (!bus->is_kernel)
3358 if (!BUS_IS_OPEN(bus->state))
3361 if (bus->rqueue_size > 0)
3364 if (bus->wqueue_size > 0)
3367 r = bus_kernel_try_close(bus);
3375 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3376 assert_return(bus, -EINVAL);
3377 assert_return(name, -EINVAL);
3378 assert_return(!bus_pid_changed(bus), -ECHILD);
3380 *name = bus->connection_name;
3384 int bus_get_root_path(sd_bus *bus) {
3387 if (bus->cgroup_root)
3390 r = cg_get_root_path(&bus->cgroup_root);
3392 bus->cgroup_root = strdup("/");
3393 if (!bus->cgroup_root)