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);
357 r = sd_bus_message_read(reply, "s", &s);
361 if (!service_name_is_valid(s) || s[0] != ':')
364 bus->unique_name = strdup(s);
365 if (!bus->unique_name)
368 if (bus->state == BUS_HELLO)
369 bus->state = BUS_RUNNING;
374 static int bus_send_hello(sd_bus *bus) {
375 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
380 if (!bus->bus_client || bus->is_kernel)
383 r = sd_bus_message_new_method_call(
386 "org.freedesktop.DBus",
387 "/org/freedesktop/DBus",
388 "org.freedesktop.DBus",
393 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
396 int bus_start_running(sd_bus *bus) {
399 if (bus->bus_client && !bus->is_kernel) {
400 bus->state = BUS_HELLO;
404 bus->state = BUS_RUNNING;
408 static int parse_address_key(const char **p, const char *key, char **value) {
409 size_t l, n = 0, allocated = 0;
419 if (strncmp(*p, key, l) != 0)
432 while (*a != ';' && *a != ',' && *a != 0) {
450 c = (char) ((x << 4) | y);
457 if (!GREEDY_REALLOC(r, allocated, n + 2))
481 static void skip_address_key(const char **p) {
485 *p += strcspn(*p, ",");
491 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
492 _cleanup_free_ char *path = NULL, *abstract = NULL;
501 while (**p != 0 && **p != ';') {
502 r = parse_address_key(p, "guid", guid);
508 r = parse_address_key(p, "path", &path);
514 r = parse_address_key(p, "abstract", &abstract);
523 if (!path && !abstract)
526 if (path && abstract)
531 if (l > sizeof(b->sockaddr.un.sun_path))
534 b->sockaddr.un.sun_family = AF_UNIX;
535 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
536 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
537 } else if (abstract) {
538 l = strlen(abstract);
539 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
542 b->sockaddr.un.sun_family = AF_UNIX;
543 b->sockaddr.un.sun_path[0] = 0;
544 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
545 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
551 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
552 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
554 struct addrinfo *result, hints = {
555 .ai_socktype = SOCK_STREAM,
556 .ai_flags = AI_ADDRCONFIG,
564 while (**p != 0 && **p != ';') {
565 r = parse_address_key(p, "guid", guid);
571 r = parse_address_key(p, "host", &host);
577 r = parse_address_key(p, "port", &port);
583 r = parse_address_key(p, "family", &family);
596 if (streq(family, "ipv4"))
597 hints.ai_family = AF_INET;
598 else if (streq(family, "ipv6"))
599 hints.ai_family = AF_INET6;
604 r = getaddrinfo(host, port, &hints, &result);
608 return -EADDRNOTAVAIL;
610 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
611 b->sockaddr_size = result->ai_addrlen;
613 freeaddrinfo(result);
618 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
620 unsigned n_argv = 0, j;
622 size_t allocated = 0;
630 while (**p != 0 && **p != ';') {
631 r = parse_address_key(p, "guid", guid);
637 r = parse_address_key(p, "path", &path);
643 if (startswith(*p, "argv")) {
647 ul = strtoul(*p + 4, (char**) p, 10);
648 if (errno > 0 || **p != '=' || ul > 256) {
656 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
664 r = parse_address_key(p, NULL, argv + ul);
679 /* Make sure there are no holes in the array, with the
680 * exception of argv[0] */
681 for (j = 1; j < n_argv; j++)
687 if (argv && argv[0] == NULL) {
688 argv[0] = strdup(path);
700 for (j = 0; j < n_argv; j++)
708 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
709 _cleanup_free_ char *path = NULL;
717 while (**p != 0 && **p != ';') {
718 r = parse_address_key(p, "guid", guid);
724 r = parse_address_key(p, "path", &path);
743 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
744 _cleanup_free_ char *machine = NULL;
752 while (**p != 0 && **p != ';') {
753 r = parse_address_key(p, "guid", guid);
759 r = parse_address_key(p, "machine", &machine);
771 if (!filename_is_safe(machine))
775 b->machine = machine;
778 b->sockaddr.un.sun_family = AF_UNIX;
779 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
780 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
785 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
786 _cleanup_free_ char *machine = NULL;
794 while (**p != 0 && **p != ';') {
795 r = parse_address_key(p, "guid", guid);
801 r = parse_address_key(p, "machine", &machine);
813 if (!filename_is_safe(machine))
817 b->machine = machine;
821 b->kernel = strdup("/dev/kdbus/0-system/bus");
828 static void bus_reset_parsed_address(sd_bus *b) {
832 b->sockaddr_size = 0;
833 strv_free(b->exec_argv);
837 b->server_id = SD_ID128_NULL;
844 static int bus_parse_next_address(sd_bus *b) {
845 _cleanup_free_ char *guid = NULL;
853 if (b->address[b->address_index] == 0)
856 bus_reset_parsed_address(b);
858 a = b->address + b->address_index;
867 if (startswith(a, "unix:")) {
870 r = parse_unix_address(b, &a, &guid);
875 } else if (startswith(a, "tcp:")) {
878 r = parse_tcp_address(b, &a, &guid);
884 } else if (startswith(a, "unixexec:")) {
887 r = parse_exec_address(b, &a, &guid);
893 } else if (startswith(a, "kernel:")) {
896 r = parse_kernel_address(b, &a, &guid);
901 } else if (startswith(a, "x-container-unix:")) {
904 r = parse_container_unix_address(b, &a, &guid);
909 } else if (startswith(a, "x-container-kernel:")) {
912 r = parse_container_kernel_address(b, &a, &guid);
925 r = sd_id128_from_string(guid, &b->server_id);
930 b->address_index = a - b->address;
934 static int bus_start_address(sd_bus *b) {
940 bool skipped = false;
945 r = bus_socket_exec(b);
946 else if (b->machine && b->kernel)
947 r = bus_container_connect_kernel(b);
948 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
949 r = bus_container_connect_socket(b);
951 r = bus_kernel_connect(b);
952 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
953 r = bus_socket_connect(b);
959 r = attach_io_events(b);
964 b->last_connect_error = -r;
967 r = bus_parse_next_address(b);
971 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
975 int bus_next_address(sd_bus *b) {
978 bus_reset_parsed_address(b);
979 return bus_start_address(b);
982 static int bus_start_fd(sd_bus *b) {
987 assert(b->input_fd >= 0);
988 assert(b->output_fd >= 0);
990 r = fd_nonblock(b->input_fd, true);
994 r = fd_cloexec(b->input_fd, true);
998 if (b->input_fd != b->output_fd) {
999 r = fd_nonblock(b->output_fd, true);
1003 r = fd_cloexec(b->output_fd, true);
1008 if (fstat(b->input_fd, &st) < 0)
1011 if (S_ISCHR(b->input_fd))
1012 return bus_kernel_take_fd(b);
1014 return bus_socket_take_fd(b);
1017 _public_ int sd_bus_start(sd_bus *bus) {
1020 assert_return(bus, -EINVAL);
1021 assert_return(bus->state == BUS_UNSET, -EPERM);
1022 assert_return(!bus_pid_changed(bus), -ECHILD);
1024 bus->state = BUS_OPENING;
1026 if (bus->is_server && bus->bus_client)
1029 if (bus->input_fd >= 0)
1030 r = bus_start_fd(bus);
1031 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1032 r = bus_start_address(bus);
1041 return bus_send_hello(bus);
1044 _public_ int sd_bus_open(sd_bus **ret) {
1049 assert_return(ret, -EINVAL);
1051 /* Let's connect to the starter bus if it is set, and
1052 * otherwise to the bus that is appropropriate for the scope
1053 * we are running in */
1055 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1057 if (streq(e, "system"))
1058 return sd_bus_open_system(ret);
1059 else if (STR_IN_SET(e, "session", "user"))
1060 return sd_bus_open_user(ret);
1063 e = secure_getenv("DBUS_STARTER_ADDRESS");
1065 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1066 return sd_bus_open_user(ret);
1068 return sd_bus_open_system(ret);
1075 r = sd_bus_set_address(b, e);
1079 b->bus_client = true;
1081 /* We don't know whether the bus is trusted or not, so better
1082 * be safe, and authenticate everything */
1084 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1086 r = sd_bus_start(b);
1098 int bus_set_address_system(sd_bus *b) {
1102 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1104 return sd_bus_set_address(b, e);
1106 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1109 _public_ int sd_bus_open_system(sd_bus **ret) {
1113 assert_return(ret, -EINVAL);
1119 r = bus_set_address_system(b);
1123 b->bus_client = true;
1124 b->is_system = true;
1126 /* Let's do per-method access control on the system bus. We
1127 * need the caller's UID and capability set for that. */
1129 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1131 r = sd_bus_start(b);
1143 int bus_set_address_user(sd_bus *b) {
1148 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1150 return sd_bus_set_address(b, e);
1152 e = secure_getenv("XDG_RUNTIME_DIR");
1154 _cleanup_free_ char *ee = NULL;
1156 ee = bus_address_escape(e);
1161 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1163 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1167 asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1169 return -ECONNREFUSED;
1179 _public_ int sd_bus_open_user(sd_bus **ret) {
1183 assert_return(ret, -EINVAL);
1189 r = bus_set_address_user(b);
1193 b->bus_client = true;
1196 /* We don't do any per-method access control on the user
1200 r = sd_bus_start(b);
1212 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1213 _cleanup_free_ char *e = NULL;
1214 char *m = NULL, *c = NULL;
1219 /* Let's see if we shall enter some container */
1220 m = strchr(host, ':');
1224 /* Let's make sure this is not a port of some kind,
1225 * and is a valid machine name. */
1226 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1229 /* Cut out the host part */
1230 t = strndupa(host, m - host - 1);
1231 e = bus_address_escape(t);
1235 c = strappenda(",argv4=--machine=", m);
1240 e = bus_address_escape(host);
1245 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1252 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1256 assert_return(host, -EINVAL);
1257 assert_return(ret, -EINVAL);
1259 r = sd_bus_new(&bus);
1263 r = bus_set_address_system_remote(bus, host);
1267 bus->bus_client = true;
1268 bus->trusted = false;
1270 r = sd_bus_start(bus);
1282 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1283 _cleanup_free_ char *e = NULL;
1288 e = bus_address_escape(machine);
1293 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1295 b->address = strjoin("x-container-unix:machine=", e, NULL);
1303 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1307 assert_return(machine, -EINVAL);
1308 assert_return(ret, -EINVAL);
1309 assert_return(filename_is_safe(machine), -EINVAL);
1311 r = sd_bus_new(&bus);
1315 r = bus_set_address_system_container(bus, machine);
1319 bus->bus_client = true;
1320 bus->trusted = false;
1322 r = sd_bus_start(bus);
1334 _public_ void sd_bus_close(sd_bus *bus) {
1338 if (bus->state == BUS_CLOSED)
1340 if (bus_pid_changed(bus))
1343 bus->state = BUS_CLOSED;
1345 sd_bus_detach_event(bus);
1347 /* Drop all queued messages so that they drop references to
1348 * the bus object and the bus may be freed */
1349 bus_reset_queues(bus);
1351 if (!bus->is_kernel)
1354 /* We'll leave the fd open in case this is a kernel bus, since
1355 * there might still be memblocks around that reference this
1356 * bus, and they might need to invoke the KDBUS_CMD_FREE
1357 * ioctl on the fd when they are freed. */
1360 static void bus_enter_closing(sd_bus *bus) {
1363 if (bus->state != BUS_OPENING &&
1364 bus->state != BUS_AUTHENTICATING &&
1365 bus->state != BUS_HELLO &&
1366 bus->state != BUS_RUNNING)
1369 bus->state = BUS_CLOSING;
1372 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1373 assert_return(bus, NULL);
1375 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1380 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1386 i = REFCNT_DEC(bus->n_ref);
1394 _public_ int sd_bus_is_open(sd_bus *bus) {
1396 assert_return(bus, -EINVAL);
1397 assert_return(!bus_pid_changed(bus), -ECHILD);
1399 return BUS_IS_OPEN(bus->state);
1402 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1405 assert_return(bus, -EINVAL);
1406 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1407 assert_return(!bus_pid_changed(bus), -ECHILD);
1409 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1412 if (type == SD_BUS_TYPE_UNIX_FD) {
1413 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1416 r = bus_ensure_running(bus);
1420 return bus->can_fds;
1423 return bus_type_is_valid(type);
1426 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1429 assert_return(bus, -EINVAL);
1430 assert_return(server_id, -EINVAL);
1431 assert_return(!bus_pid_changed(bus), -ECHILD);
1433 r = bus_ensure_running(bus);
1437 *server_id = bus->server_id;
1441 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1446 /* If we copy the same message to multiple
1447 * destinations, avoid using the same cookie
1449 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1454 timeout = BUS_DEFAULT_TIMEOUT;
1456 return bus_message_seal(m, ++b->cookie, timeout);
1459 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1462 /* Do packet version and endianness already match? */
1463 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1464 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1467 /* No? Then remarshal! */
1468 return bus_message_remarshal(b, m);
1471 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1475 /* The bus specification says the serial number cannot be 0,
1476 * hence let's fill something in for synthetic messages. Since
1477 * synthetic messages might have a fake sender and we don't
1478 * want to interfere with the real sender's serial numbers we
1479 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1480 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1481 * even though kdbus can do 64bit. */
1483 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1486 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1493 r = bus_kernel_write_message(bus, m, hint_sync_call);
1495 r = bus_socket_write_message(bus, m, idx);
1500 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1501 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1502 bus_message_type_to_string(m->header->type),
1503 strna(sd_bus_message_get_sender(m)),
1504 strna(sd_bus_message_get_destination(m)),
1505 strna(sd_bus_message_get_path(m)),
1506 strna(sd_bus_message_get_interface(m)),
1507 strna(sd_bus_message_get_member(m)),
1508 BUS_MESSAGE_COOKIE(m),
1510 strna(m->error.message));
1515 static int dispatch_wqueue(sd_bus *bus) {
1519 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1521 while (bus->wqueue_size > 0) {
1523 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1527 /* Didn't do anything this time */
1529 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1530 /* Fully written. Let's drop the entry from
1533 * This isn't particularly optimized, but
1534 * well, this is supposed to be our worst-case
1535 * buffer only, and the socket buffer is
1536 * supposed to be our primary buffer, and if
1537 * it got full, then all bets are off
1540 bus->wqueue_size --;
1541 sd_bus_message_unref(bus->wqueue[0]);
1542 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1552 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1556 return bus_kernel_read_message(bus, hint_priority, priority);
1558 return bus_socket_read_message(bus);
1561 int bus_rqueue_make_room(sd_bus *bus) {
1564 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1567 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1573 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1578 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1580 /* Note that the priority logic is only available on kdbus,
1581 * where the rqueue is unused. We check the rqueue here
1582 * anyway, because it's simple... */
1585 if (bus->rqueue_size > 0) {
1586 /* Dispatch a queued message */
1588 *m = bus->rqueue[0];
1589 bus->rqueue_size --;
1590 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1594 /* Try to read a new message */
1595 r = bus_read_message(bus, hint_priority, priority);
1605 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1606 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1609 assert_return(bus, -EINVAL);
1610 assert_return(m, -EINVAL);
1611 assert_return(!bus_pid_changed(bus), -ECHILD);
1612 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1614 if (!BUS_IS_OPEN(bus->state))
1618 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1625 /* If the cookie number isn't kept, then we know that no reply
1627 if (!cookie && !m->sealed)
1628 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1630 r = bus_seal_message(bus, m, 0);
1634 /* Remarshall if we have to. This will possibly unref the
1635 * message and place a replacement in m */
1636 r = bus_remarshal_message(bus, &m);
1640 /* If this is a reply and no reply was requested, then let's
1641 * suppress this, if we can */
1642 if (m->dont_send && !cookie)
1645 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1648 r = bus_write_message(bus, m, hint_sync_call, &idx);
1650 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1651 bus_enter_closing(bus);
1656 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1657 /* Wasn't fully written. So let's remember how
1658 * much was written. Note that the first entry
1659 * of the wqueue array is always allocated so
1660 * that we always can remember how much was
1662 bus->wqueue[0] = sd_bus_message_ref(m);
1663 bus->wqueue_size = 1;
1667 /* Just append it to the queue. */
1669 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1672 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1675 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1679 *cookie = BUS_MESSAGE_COOKIE(m);
1684 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1685 return bus_send_internal(bus, m, cookie, false);
1688 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1691 assert_return(bus, -EINVAL);
1692 assert_return(m, -EINVAL);
1693 assert_return(!bus_pid_changed(bus), -ECHILD);
1695 if (!BUS_IS_OPEN(bus->state))
1698 if (!streq_ptr(m->destination, destination)) {
1703 r = sd_bus_message_set_destination(m, destination);
1708 return sd_bus_send(bus, m, cookie);
1711 static usec_t calc_elapse(uint64_t usec) {
1712 if (usec == (uint64_t) -1)
1715 return now(CLOCK_MONOTONIC) + usec;
1718 static int timeout_compare(const void *a, const void *b) {
1719 const struct reply_callback *x = a, *y = b;
1721 if (x->timeout != 0 && y->timeout == 0)
1724 if (x->timeout == 0 && y->timeout != 0)
1727 if (x->timeout < y->timeout)
1730 if (x->timeout > y->timeout)
1736 _public_ int sd_bus_call_async(
1740 sd_bus_message_handler_t callback,
1744 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1745 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1748 assert_return(bus, -EINVAL);
1749 assert_return(m, -EINVAL);
1750 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1751 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1752 assert_return(callback, -EINVAL);
1753 assert_return(!bus_pid_changed(bus), -ECHILD);
1754 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1756 if (!BUS_IS_OPEN(bus->state))
1759 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1763 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1767 r = bus_seal_message(bus, m, usec);
1771 r = bus_remarshal_message(bus, &m);
1775 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1779 s->reply_callback.callback = callback;
1781 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1782 r = hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1784 s->reply_callback.cookie = 0;
1788 s->reply_callback.timeout = calc_elapse(m->timeout);
1789 if (s->reply_callback.timeout != 0) {
1790 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1792 s->reply_callback.timeout = 0;
1797 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1808 int bus_ensure_running(sd_bus *bus) {
1813 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1815 if (bus->state == BUS_RUNNING)
1819 r = sd_bus_process(bus, NULL);
1822 if (bus->state == BUS_RUNNING)
1827 r = sd_bus_wait(bus, (uint64_t) -1);
1833 _public_ int sd_bus_call(
1837 sd_bus_error *error,
1838 sd_bus_message **reply) {
1840 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1846 assert_return(bus, -EINVAL);
1847 assert_return(m, -EINVAL);
1848 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1849 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1850 assert_return(!bus_error_is_dirty(error), -EINVAL);
1851 assert_return(!bus_pid_changed(bus), -ECHILD);
1852 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1854 if (!BUS_IS_OPEN(bus->state))
1857 r = bus_ensure_running(bus);
1861 i = bus->rqueue_size;
1863 r = bus_seal_message(bus, m, usec);
1867 r = bus_remarshal_message(bus, &m);
1871 r = bus_send_internal(bus, m, &cookie, true);
1875 timeout = calc_elapse(m->timeout);
1880 while (i < bus->rqueue_size) {
1881 sd_bus_message *incoming = NULL;
1883 incoming = bus->rqueue[i];
1885 if (incoming->reply_cookie == cookie) {
1886 /* Found a match! */
1888 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1891 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1893 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1897 sd_bus_message_unref(incoming);
1902 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1904 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1905 r = sd_bus_error_copy(error, &incoming->error);
1909 sd_bus_message_unref(incoming);
1912 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1915 streq(bus->unique_name, incoming->sender)) {
1917 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1920 /* Our own message? Somebody is trying
1921 * to send its own client a message,
1922 * let's not dead-lock, let's fail
1925 sd_bus_message_unref(incoming);
1929 /* Try to read more, right-away */
1933 r = bus_read_message(bus, false, 0);
1935 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1936 bus_enter_closing(bus);
1948 n = now(CLOCK_MONOTONIC);
1954 left = (uint64_t) -1;
1956 r = bus_poll(bus, true, left);
1962 r = dispatch_wqueue(bus);
1964 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1965 bus_enter_closing(bus);
1974 _public_ int sd_bus_get_fd(sd_bus *bus) {
1976 assert_return(bus, -EINVAL);
1977 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1978 assert_return(!bus_pid_changed(bus), -ECHILD);
1980 return bus->input_fd;
1983 _public_ int sd_bus_get_events(sd_bus *bus) {
1986 assert_return(bus, -EINVAL);
1987 assert_return(!bus_pid_changed(bus), -ECHILD);
1989 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1992 if (bus->state == BUS_OPENING)
1994 else if (bus->state == BUS_AUTHENTICATING) {
1996 if (bus_socket_auth_needs_write(bus))
2001 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2002 if (bus->rqueue_size <= 0)
2004 if (bus->wqueue_size > 0)
2011 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2012 struct reply_callback *c;
2014 assert_return(bus, -EINVAL);
2015 assert_return(timeout_usec, -EINVAL);
2016 assert_return(!bus_pid_changed(bus), -ECHILD);
2018 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2021 if (bus->track_queue) {
2026 if (bus->state == BUS_CLOSING) {
2031 if (bus->state == BUS_AUTHENTICATING) {
2032 *timeout_usec = bus->auth_timeout;
2036 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2037 *timeout_usec = (uint64_t) -1;
2041 if (bus->rqueue_size > 0) {
2046 c = prioq_peek(bus->reply_callbacks_prioq);
2048 *timeout_usec = (uint64_t) -1;
2052 if (c->timeout == 0) {
2053 *timeout_usec = (uint64_t) -1;
2057 *timeout_usec = c->timeout;
2061 static int process_timeout(sd_bus *bus) {
2062 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2063 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2064 struct reply_callback *c;
2071 c = prioq_peek(bus->reply_callbacks_prioq);
2075 n = now(CLOCK_MONOTONIC);
2079 r = bus_message_new_synthetic_error(
2082 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2087 m->sender = "org.freedesktop.DBus";
2089 r = bus_seal_synthetic_message(bus, m);
2093 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2096 hashmap_remove(bus->reply_callbacks, &c->cookie);
2099 slot = container_of(c, sd_bus_slot, reply_callback);
2101 bus->iteration_counter ++;
2103 bus->current_message = m;
2104 bus->current_slot = sd_bus_slot_ref(slot);
2105 bus->current_handler = c->callback;
2106 bus->current_userdata = slot->userdata;
2107 r = c->callback(bus, m, slot->userdata, &error_buffer);
2108 bus->current_userdata = NULL;
2109 bus->current_handler = NULL;
2110 bus->current_slot = sd_bus_slot_unref(slot);
2111 bus->current_message = NULL;
2113 if (slot->floating) {
2114 bus_slot_disconnect(slot);
2115 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 = sd_bus_slot_unref(slot);
2208 if (slot->floating) {
2209 bus_slot_disconnect(slot);
2210 sd_bus_slot_unref(slot);
2213 return bus_maybe_reply_error(m, r, &error_buffer);
2216 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2217 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2218 struct filter_callback *l;
2225 bus->filter_callbacks_modified = false;
2227 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2230 if (bus->filter_callbacks_modified)
2233 /* Don't run this more than once per iteration */
2234 if (l->last_iteration == bus->iteration_counter)
2237 l->last_iteration = bus->iteration_counter;
2239 r = sd_bus_message_rewind(m, true);
2243 slot = container_of(l, sd_bus_slot, filter_callback);
2245 bus->current_slot = sd_bus_slot_ref(slot);
2246 bus->current_handler = l->callback;
2247 bus->current_userdata = slot->userdata;
2248 r = l->callback(bus, m, slot->userdata, &error_buffer);
2249 bus->current_userdata = NULL;
2250 bus->current_handler = NULL;
2251 bus->current_slot = sd_bus_slot_unref(slot);
2253 r = bus_maybe_reply_error(m, r, &error_buffer);
2259 } while (bus->filter_callbacks_modified);
2264 static int process_match(sd_bus *bus, sd_bus_message *m) {
2271 bus->match_callbacks_modified = false;
2273 r = bus_match_run(bus, &bus->match_callbacks, m);
2277 } while (bus->match_callbacks_modified);
2282 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2283 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2289 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2292 if (bus->manual_peer_interface)
2295 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2298 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2301 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2304 if (streq_ptr(m->member, "Ping"))
2305 r = sd_bus_message_new_method_return(m, &reply);
2306 else if (streq_ptr(m->member, "GetMachineId")) {
2310 r = sd_id128_get_machine(&id);
2314 r = sd_bus_message_new_method_return(m, &reply);
2318 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2320 r = sd_bus_message_new_method_errorf(
2322 SD_BUS_ERROR_UNKNOWN_METHOD,
2323 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2329 r = sd_bus_send(bus, reply, NULL);
2336 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2340 /* If we got a message with a file descriptor which we didn't
2341 * want to accept, then let's drop it. How can this even
2342 * happen? For example, when the kernel queues a message into
2343 * an activatable names's queue which allows fds, and then is
2344 * delivered to us later even though we ourselves did not
2347 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2353 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2356 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2357 return 1; /* just eat it up */
2359 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2362 static int process_message(sd_bus *bus, sd_bus_message *m) {
2368 bus->current_message = m;
2369 bus->iteration_counter++;
2371 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2372 bus_message_type_to_string(m->header->type),
2373 strna(sd_bus_message_get_sender(m)),
2374 strna(sd_bus_message_get_destination(m)),
2375 strna(sd_bus_message_get_path(m)),
2376 strna(sd_bus_message_get_interface(m)),
2377 strna(sd_bus_message_get_member(m)),
2378 BUS_MESSAGE_COOKIE(m),
2380 strna(m->error.message));
2382 r = process_hello(bus, m);
2386 r = process_reply(bus, m);
2390 r = process_fd_check(bus, m);
2394 r = process_filter(bus, m);
2398 r = process_match(bus, m);
2402 r = process_builtin(bus, m);
2406 r = bus_process_object(bus, m);
2409 bus->current_message = NULL;
2413 static int dispatch_track(sd_bus *bus) {
2416 if (!bus->track_queue)
2419 bus_track_dispatch(bus->track_queue);
2423 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2424 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2428 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2430 r = process_timeout(bus);
2434 r = dispatch_wqueue(bus);
2438 r = dispatch_track(bus);
2442 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2448 r = process_message(bus, m);
2453 r = sd_bus_message_rewind(m, true);
2462 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2464 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2465 strna(sd_bus_message_get_sender(m)),
2466 strna(sd_bus_message_get_path(m)),
2467 strna(sd_bus_message_get_interface(m)),
2468 strna(sd_bus_message_get_member(m)));
2470 r = sd_bus_reply_method_errorf(
2472 SD_BUS_ERROR_UNKNOWN_OBJECT,
2473 "Unknown object '%s'.", m->path);
2487 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2488 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2489 struct reply_callback *c;
2493 assert(bus->state == BUS_CLOSING);
2495 c = hashmap_first(bus->reply_callbacks);
2497 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2500 /* First, fail all outstanding method calls */
2501 r = bus_message_new_synthetic_error(
2504 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2509 r = bus_seal_synthetic_message(bus, m);
2513 if (c->timeout != 0) {
2514 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2518 hashmap_remove(bus->reply_callbacks, &c->cookie);
2521 slot = container_of(c, sd_bus_slot, reply_callback);
2523 bus->iteration_counter++;
2525 bus->current_message = m;
2526 bus->current_slot = sd_bus_slot_ref(slot);
2527 bus->current_handler = c->callback;
2528 bus->current_userdata = slot->userdata;
2529 r = c->callback(bus, m, slot->userdata, &error_buffer);
2530 bus->current_userdata = NULL;
2531 bus->current_handler = NULL;
2532 bus->current_slot = sd_bus_slot_unref(slot);
2533 bus->current_message = NULL;
2535 if (slot->floating) {
2536 bus_slot_disconnect(slot);
2537 sd_bus_slot_unref(slot);
2540 return bus_maybe_reply_error(m, r, &error_buffer);
2543 /* Then, synthesize a Disconnected message */
2544 r = sd_bus_message_new_signal(
2547 "/org/freedesktop/DBus/Local",
2548 "org.freedesktop.DBus.Local",
2553 m->sender = "org.freedesktop.DBus.Local";
2555 r = bus_seal_synthetic_message(bus, m);
2561 bus->current_message = m;
2562 bus->iteration_counter++;
2564 r = process_filter(bus, m);
2568 r = process_match(bus, m);
2580 bus->current_message = NULL;
2585 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2586 BUS_DONT_DESTROY(bus);
2589 /* Returns 0 when we didn't do anything. This should cause the
2590 * caller to invoke sd_bus_wait() before returning the next
2591 * time. Returns > 0 when we did something, which possibly
2592 * means *ret is filled in with an unprocessed message. */
2594 assert_return(bus, -EINVAL);
2595 assert_return(!bus_pid_changed(bus), -ECHILD);
2597 /* We don't allow recursively invoking sd_bus_process(). */
2598 assert_return(!bus->current_message, -EBUSY);
2599 assert(!bus->current_slot);
2601 switch (bus->state) {
2610 r = bus_socket_process_opening(bus);
2611 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2612 bus_enter_closing(bus);
2620 case BUS_AUTHENTICATING:
2621 r = bus_socket_process_authenticating(bus);
2622 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2623 bus_enter_closing(bus);
2635 r = process_running(bus, hint_priority, priority, ret);
2636 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2637 bus_enter_closing(bus);
2647 return process_closing(bus, ret);
2650 assert_not_reached("Unknown state");
2653 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2654 return bus_process_internal(bus, false, 0, ret);
2657 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2658 return bus_process_internal(bus, true, priority, ret);
2661 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2662 struct pollfd p[2] = {};
2665 usec_t m = USEC_INFINITY;
2669 if (bus->state == BUS_CLOSING)
2672 if (!BUS_IS_OPEN(bus->state))
2675 e = sd_bus_get_events(bus);
2680 /* The caller really needs some more data, he doesn't
2681 * care about what's already read, or any timeouts
2686 /* The caller wants to process if there's something to
2687 * process, but doesn't care otherwise */
2689 r = sd_bus_get_timeout(bus, &until);
2694 nw = now(CLOCK_MONOTONIC);
2695 m = until > nw ? until - nw : 0;
2699 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2702 p[0].fd = bus->input_fd;
2703 if (bus->output_fd == bus->input_fd) {
2707 p[0].events = e & POLLIN;
2708 p[1].fd = bus->output_fd;
2709 p[1].events = e & POLLOUT;
2713 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2717 return r > 0 ? 1 : 0;
2720 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2722 assert_return(bus, -EINVAL);
2723 assert_return(!bus_pid_changed(bus), -ECHILD);
2725 if (bus->state == BUS_CLOSING)
2728 if (!BUS_IS_OPEN(bus->state))
2731 if (bus->rqueue_size > 0)
2734 return bus_poll(bus, false, timeout_usec);
2737 _public_ int sd_bus_flush(sd_bus *bus) {
2740 assert_return(bus, -EINVAL);
2741 assert_return(!bus_pid_changed(bus), -ECHILD);
2743 if (bus->state == BUS_CLOSING)
2746 if (!BUS_IS_OPEN(bus->state))
2749 r = bus_ensure_running(bus);
2753 if (bus->wqueue_size <= 0)
2757 r = dispatch_wqueue(bus);
2759 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2760 bus_enter_closing(bus);
2767 if (bus->wqueue_size <= 0)
2770 r = bus_poll(bus, false, (uint64_t) -1);
2776 _public_ int sd_bus_add_filter(
2779 sd_bus_message_handler_t callback,
2784 assert_return(bus, -EINVAL);
2785 assert_return(callback, -EINVAL);
2786 assert_return(!bus_pid_changed(bus), -ECHILD);
2788 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2792 s->filter_callback.callback = callback;
2794 bus->filter_callbacks_modified = true;
2795 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2803 _public_ int sd_bus_add_match(
2807 sd_bus_message_handler_t callback,
2810 struct bus_match_component *components = NULL;
2811 unsigned n_components = 0;
2812 sd_bus_slot *s = NULL;
2815 assert_return(bus, -EINVAL);
2816 assert_return(match, -EINVAL);
2817 assert_return(!bus_pid_changed(bus), -ECHILD);
2819 r = bus_match_parse(match, &components, &n_components);
2823 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2829 s->match_callback.callback = callback;
2830 s->match_callback.cookie = ++bus->match_cookie;
2832 if (bus->bus_client) {
2834 if (!bus->is_kernel) {
2835 /* When this is not a kernel transport, we
2836 * store the original match string, so that we
2837 * can use it to remove the match again */
2839 s->match_callback.match_string = strdup(match);
2840 if (!s->match_callback.match_string) {
2846 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2851 bus->match_callbacks_modified = true;
2852 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2861 bus_match_parse_free(components, n_components);
2862 sd_bus_slot_unref(s);
2867 int bus_remove_match_by_string(
2870 sd_bus_message_handler_t callback,
2873 struct bus_match_component *components = NULL;
2874 unsigned n_components = 0;
2875 struct match_callback *c;
2878 assert_return(bus, -EINVAL);
2879 assert_return(match, -EINVAL);
2880 assert_return(!bus_pid_changed(bus), -ECHILD);
2882 r = bus_match_parse(match, &components, &n_components);
2886 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2890 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2893 bus_match_parse_free(components, n_components);
2898 bool bus_pid_changed(sd_bus *bus) {
2901 /* We don't support people creating a bus connection and
2902 * keeping it around over a fork(). Let's complain. */
2904 return bus->original_pid != getpid();
2907 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2908 sd_bus *bus = userdata;
2913 r = sd_bus_process(bus, NULL);
2920 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2921 sd_bus *bus = userdata;
2926 r = sd_bus_process(bus, NULL);
2933 static int prepare_callback(sd_event_source *s, void *userdata) {
2934 sd_bus *bus = userdata;
2941 e = sd_bus_get_events(bus);
2945 if (bus->output_fd != bus->input_fd) {
2947 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2951 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2955 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2960 r = sd_bus_get_timeout(bus, &until);
2966 j = sd_event_source_set_time(bus->time_event_source, until);
2971 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2978 static int quit_callback(sd_event_source *event, void *userdata) {
2979 sd_bus *bus = userdata;
2989 static int attach_io_events(sd_bus *bus) {
2994 if (bus->input_fd < 0)
3000 if (!bus->input_io_event_source) {
3001 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3005 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3009 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3011 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3016 if (bus->output_fd != bus->input_fd) {
3017 assert(bus->output_fd >= 0);
3019 if (!bus->output_io_event_source) {
3020 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3024 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3026 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3035 static void detach_io_events(sd_bus *bus) {
3038 if (bus->input_io_event_source) {
3039 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3040 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3043 if (bus->output_io_event_source) {
3044 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3045 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3049 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3052 assert_return(bus, -EINVAL);
3053 assert_return(!bus->event, -EBUSY);
3055 assert(!bus->input_io_event_source);
3056 assert(!bus->output_io_event_source);
3057 assert(!bus->time_event_source);
3060 bus->event = sd_event_ref(event);
3062 r = sd_event_default(&bus->event);
3067 bus->event_priority = priority;
3069 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3073 r = sd_event_source_set_priority(bus->time_event_source, priority);
3077 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3081 r = attach_io_events(bus);
3088 sd_bus_detach_event(bus);
3092 _public_ int sd_bus_detach_event(sd_bus *bus) {
3093 assert_return(bus, -EINVAL);
3098 detach_io_events(bus);
3100 if (bus->time_event_source) {
3101 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3102 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3105 if (bus->quit_event_source) {
3106 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3107 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3110 bus->event = sd_event_unref(bus->event);
3114 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3115 assert_return(bus, NULL);
3120 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3121 assert_return(bus, NULL);
3123 return bus->current_message;
3126 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3127 assert_return(bus, NULL);
3129 return bus->current_slot;
3132 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3133 assert_return(bus, NULL);
3135 return bus->current_handler;
3138 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3139 assert_return(bus, NULL);
3141 return bus->current_userdata;
3144 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3149 assert(default_bus);
3152 return !!*default_bus;
3155 *ret = sd_bus_ref(*default_bus);
3163 b->default_bus_ptr = default_bus;
3171 _public_ int sd_bus_default_system(sd_bus **ret) {
3172 static thread_local sd_bus *default_system_bus = NULL;
3174 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3177 _public_ int sd_bus_default_user(sd_bus **ret) {
3178 static thread_local sd_bus *default_user_bus = NULL;
3180 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3183 _public_ int sd_bus_default(sd_bus **ret) {
3187 /* Let's try our best to reuse another cached connection. If
3188 * the starter bus type is set, connect via our normal
3189 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3190 * we can share the connection with the user/system default
3193 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3195 if (streq(e, "system"))
3196 return sd_bus_default_system(ret);
3197 else if (STR_IN_SET(e, "user", "session"))
3198 return sd_bus_default_user(ret);
3201 /* No type is specified, so we have not other option than to
3202 * use the starter address if it is set. */
3204 e = secure_getenv("DBUS_STARTER_ADDRESS");
3206 static thread_local sd_bus *default_starter_bus = NULL;
3208 return bus_default(sd_bus_open, &default_starter_bus, ret);
3211 /* Finally, if nothing is set use the cached connection for
3212 * the right scope */
3214 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3215 return sd_bus_default_user(ret);
3217 return sd_bus_default_system(ret);
3220 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3221 assert_return(b, -EINVAL);
3222 assert_return(tid, -EINVAL);
3223 assert_return(!bus_pid_changed(b), -ECHILD);
3231 return sd_event_get_tid(b->event, tid);
3236 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3237 _cleanup_free_ char *e = NULL;
3240 assert_return(object_path_is_valid(prefix), -EINVAL);
3241 assert_return(external_id, -EINVAL);
3242 assert_return(ret_path, -EINVAL);
3244 e = bus_label_escape(external_id);
3248 ret = strjoin(prefix, "/", e, NULL);
3256 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3260 assert_return(object_path_is_valid(path), -EINVAL);
3261 assert_return(object_path_is_valid(prefix), -EINVAL);
3262 assert_return(external_id, -EINVAL);
3264 e = object_path_startswith(path, prefix);
3266 *external_id = NULL;
3270 ret = bus_label_unescape(e);
3278 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3283 assert_return(bus, -EINVAL);
3284 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3285 assert_return(ret, -EINVAL);
3286 assert_return(!bus_pid_changed(bus), -ECHILD);
3291 if (!BUS_IS_OPEN(bus->state))
3294 if (!bus->ucred_valid && !isempty(bus->label))
3297 c = bus_creds_new();
3301 if (bus->ucred_valid) {
3302 pid = c->pid = bus->ucred.pid;
3303 c->uid = bus->ucred.uid;
3304 c->gid = bus->ucred.gid;
3306 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3309 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3310 c->label = strdup(bus->label);
3312 sd_bus_creds_unref(c);
3316 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3319 r = bus_creds_add_more(c, mask, pid, 0);
3327 _public_ int sd_bus_try_close(sd_bus *bus) {
3330 assert_return(bus, -EINVAL);
3331 assert_return(!bus_pid_changed(bus), -ECHILD);
3333 if (!bus->is_kernel)
3336 if (!BUS_IS_OPEN(bus->state))
3339 if (bus->rqueue_size > 0)
3342 if (bus->wqueue_size > 0)
3345 r = bus_kernel_try_close(bus);
3353 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3354 assert_return(bus, -EINVAL);
3355 assert_return(name, -EINVAL);
3356 assert_return(!bus_pid_changed(bus), -ECHILD);
3358 *name = bus->connection_name;
3362 int bus_get_root_path(sd_bus *bus) {
3365 if (bus->cgroup_root)
3368 r = cg_get_root_path(&bus->cgroup_root);
3370 bus->cgroup_root = strdup("/");
3371 if (!bus->cgroup_root)