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 r = c->callback(bus, m, slot->userdata, &error_buffer);
2106 bus->current_slot = sd_bus_slot_unref(slot);
2107 bus->current_message = NULL;
2109 if (slot->floating) {
2110 bus_slot_disconnect(slot);
2111 sd_bus_slot_unref(slot);
2114 return bus_maybe_reply_error(m, r, &error_buffer);
2117 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2121 if (bus->state != BUS_HELLO)
2124 /* Let's make sure the first message on the bus is the HELLO
2125 * reply. But note that we don't actually parse the message
2126 * here (we leave that to the usual handling), we just verify
2127 * we don't let any earlier msg through. */
2129 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2130 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2133 if (m->reply_cookie != 1)
2139 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2140 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2141 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2142 struct reply_callback *c;
2149 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2150 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2153 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2156 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2159 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2165 slot = container_of(c, sd_bus_slot, reply_callback);
2167 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2169 /* If the reply contained a file descriptor which we
2170 * didn't want we pass an error instead. */
2172 r = bus_message_new_synthetic_error(
2175 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2180 r = bus_seal_synthetic_message(bus, synthetic_reply);
2184 m = synthetic_reply;
2186 r = sd_bus_message_rewind(m, true);
2191 if (c->timeout != 0) {
2192 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2196 bus->current_slot = sd_bus_slot_ref(slot);
2197 r = c->callback(bus, m, slot->userdata, &error_buffer);
2198 bus->current_slot = sd_bus_slot_unref(slot);
2200 if (slot->floating) {
2201 bus_slot_disconnect(slot);
2202 sd_bus_slot_unref(slot);
2205 return bus_maybe_reply_error(m, r, &error_buffer);
2208 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2209 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2210 struct filter_callback *l;
2217 bus->filter_callbacks_modified = false;
2219 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2222 if (bus->filter_callbacks_modified)
2225 /* Don't run this more than once per iteration */
2226 if (l->last_iteration == bus->iteration_counter)
2229 l->last_iteration = bus->iteration_counter;
2231 r = sd_bus_message_rewind(m, true);
2235 slot = container_of(l, sd_bus_slot, filter_callback);
2237 bus->current_slot = sd_bus_slot_ref(slot);
2238 r = l->callback(bus, m, slot->userdata, &error_buffer);
2239 bus->current_slot = sd_bus_slot_unref(slot);
2241 r = bus_maybe_reply_error(m, r, &error_buffer);
2247 } while (bus->filter_callbacks_modified);
2252 static int process_match(sd_bus *bus, sd_bus_message *m) {
2259 bus->match_callbacks_modified = false;
2261 r = bus_match_run(bus, &bus->match_callbacks, m);
2265 } while (bus->match_callbacks_modified);
2270 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2271 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2277 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2280 if (bus->manual_peer_interface)
2283 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2286 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2289 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2292 if (streq_ptr(m->member, "Ping"))
2293 r = sd_bus_message_new_method_return(m, &reply);
2294 else if (streq_ptr(m->member, "GetMachineId")) {
2298 r = sd_id128_get_machine(&id);
2302 r = sd_bus_message_new_method_return(m, &reply);
2306 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2308 r = sd_bus_message_new_method_errorf(
2310 SD_BUS_ERROR_UNKNOWN_METHOD,
2311 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2317 r = sd_bus_send(bus, reply, NULL);
2324 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2328 /* If we got a message with a file descriptor which we didn't
2329 * want to accept, then let's drop it. How can this even
2330 * happen? For example, when the kernel queues a message into
2331 * an activatable names's queue which allows fds, and then is
2332 * delivered to us later even though we ourselves did not
2335 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2341 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2344 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2345 return 1; /* just eat it up */
2347 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2350 static int process_message(sd_bus *bus, sd_bus_message *m) {
2356 bus->current_message = m;
2357 bus->iteration_counter++;
2359 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2360 bus_message_type_to_string(m->header->type),
2361 strna(sd_bus_message_get_sender(m)),
2362 strna(sd_bus_message_get_destination(m)),
2363 strna(sd_bus_message_get_path(m)),
2364 strna(sd_bus_message_get_interface(m)),
2365 strna(sd_bus_message_get_member(m)),
2366 BUS_MESSAGE_COOKIE(m),
2368 strna(m->error.message));
2370 r = process_hello(bus, m);
2374 r = process_reply(bus, m);
2378 r = process_fd_check(bus, m);
2382 r = process_filter(bus, m);
2386 r = process_match(bus, m);
2390 r = process_builtin(bus, m);
2394 r = bus_process_object(bus, m);
2397 bus->current_message = NULL;
2401 static int dispatch_track(sd_bus *bus) {
2404 if (!bus->track_queue)
2407 bus_track_dispatch(bus->track_queue);
2411 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2412 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2416 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2418 r = process_timeout(bus);
2422 r = dispatch_wqueue(bus);
2426 r = dispatch_track(bus);
2430 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2436 r = process_message(bus, m);
2441 r = sd_bus_message_rewind(m, true);
2450 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2452 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2453 strna(sd_bus_message_get_sender(m)),
2454 strna(sd_bus_message_get_path(m)),
2455 strna(sd_bus_message_get_interface(m)),
2456 strna(sd_bus_message_get_member(m)));
2458 r = sd_bus_reply_method_errorf(
2460 SD_BUS_ERROR_UNKNOWN_OBJECT,
2461 "Unknown object '%s'.", m->path);
2475 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2476 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2477 struct reply_callback *c;
2481 assert(bus->state == BUS_CLOSING);
2483 c = hashmap_first(bus->reply_callbacks);
2485 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2488 /* First, fail all outstanding method calls */
2489 r = bus_message_new_synthetic_error(
2492 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2497 r = bus_seal_synthetic_message(bus, m);
2501 if (c->timeout != 0) {
2502 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2506 hashmap_remove(bus->reply_callbacks, &c->cookie);
2509 slot = container_of(c, sd_bus_slot, reply_callback);
2511 bus->iteration_counter++;
2513 bus->current_message = m;
2514 bus->current_slot = sd_bus_slot_ref(slot);
2515 r = c->callback(bus, m, slot->userdata, &error_buffer);
2516 bus->current_slot = sd_bus_slot_unref(slot);
2517 bus->current_message = NULL;
2519 if (slot->floating) {
2520 bus_slot_disconnect(slot);
2521 sd_bus_slot_unref(slot);
2524 return bus_maybe_reply_error(m, r, &error_buffer);
2527 /* Then, synthesize a Disconnected message */
2528 r = sd_bus_message_new_signal(
2531 "/org/freedesktop/DBus/Local",
2532 "org.freedesktop.DBus.Local",
2537 m->sender = "org.freedesktop.DBus.Local";
2539 r = bus_seal_synthetic_message(bus, m);
2545 bus->current_message = m;
2546 bus->iteration_counter++;
2548 r = process_filter(bus, m);
2552 r = process_match(bus, m);
2564 bus->current_message = NULL;
2569 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2570 BUS_DONT_DESTROY(bus);
2573 /* Returns 0 when we didn't do anything. This should cause the
2574 * caller to invoke sd_bus_wait() before returning the next
2575 * time. Returns > 0 when we did something, which possibly
2576 * means *ret is filled in with an unprocessed message. */
2578 assert_return(bus, -EINVAL);
2579 assert_return(!bus_pid_changed(bus), -ECHILD);
2581 /* We don't allow recursively invoking sd_bus_process(). */
2582 assert_return(!bus->current_message, -EBUSY);
2583 assert(!bus->current_slot);
2585 switch (bus->state) {
2594 r = bus_socket_process_opening(bus);
2595 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2596 bus_enter_closing(bus);
2604 case BUS_AUTHENTICATING:
2605 r = bus_socket_process_authenticating(bus);
2606 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2607 bus_enter_closing(bus);
2619 r = process_running(bus, hint_priority, priority, ret);
2620 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2621 bus_enter_closing(bus);
2631 return process_closing(bus, ret);
2634 assert_not_reached("Unknown state");
2637 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2638 return bus_process_internal(bus, false, 0, ret);
2641 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2642 return bus_process_internal(bus, true, priority, ret);
2645 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2646 struct pollfd p[2] = {};
2649 usec_t m = USEC_INFINITY;
2653 if (bus->state == BUS_CLOSING)
2656 if (!BUS_IS_OPEN(bus->state))
2659 e = sd_bus_get_events(bus);
2664 /* The caller really needs some more data, he doesn't
2665 * care about what's already read, or any timeouts
2670 /* The caller wants to process if there's something to
2671 * process, but doesn't care otherwise */
2673 r = sd_bus_get_timeout(bus, &until);
2678 nw = now(CLOCK_MONOTONIC);
2679 m = until > nw ? until - nw : 0;
2683 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2686 p[0].fd = bus->input_fd;
2687 if (bus->output_fd == bus->input_fd) {
2691 p[0].events = e & POLLIN;
2692 p[1].fd = bus->output_fd;
2693 p[1].events = e & POLLOUT;
2697 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2701 return r > 0 ? 1 : 0;
2704 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2706 assert_return(bus, -EINVAL);
2707 assert_return(!bus_pid_changed(bus), -ECHILD);
2709 if (bus->state == BUS_CLOSING)
2712 if (!BUS_IS_OPEN(bus->state))
2715 if (bus->rqueue_size > 0)
2718 return bus_poll(bus, false, timeout_usec);
2721 _public_ int sd_bus_flush(sd_bus *bus) {
2724 assert_return(bus, -EINVAL);
2725 assert_return(!bus_pid_changed(bus), -ECHILD);
2727 if (bus->state == BUS_CLOSING)
2730 if (!BUS_IS_OPEN(bus->state))
2733 r = bus_ensure_running(bus);
2737 if (bus->wqueue_size <= 0)
2741 r = dispatch_wqueue(bus);
2743 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2744 bus_enter_closing(bus);
2751 if (bus->wqueue_size <= 0)
2754 r = bus_poll(bus, false, (uint64_t) -1);
2760 _public_ int sd_bus_add_filter(
2763 sd_bus_message_handler_t callback,
2768 assert_return(bus, -EINVAL);
2769 assert_return(callback, -EINVAL);
2770 assert_return(!bus_pid_changed(bus), -ECHILD);
2772 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2776 s->filter_callback.callback = callback;
2778 bus->filter_callbacks_modified = true;
2779 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2787 _public_ int sd_bus_add_match(
2791 sd_bus_message_handler_t callback,
2794 struct bus_match_component *components = NULL;
2795 unsigned n_components = 0;
2796 sd_bus_slot *s = NULL;
2799 assert_return(bus, -EINVAL);
2800 assert_return(match, -EINVAL);
2801 assert_return(!bus_pid_changed(bus), -ECHILD);
2803 r = bus_match_parse(match, &components, &n_components);
2807 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2813 s->match_callback.callback = callback;
2814 s->match_callback.cookie = ++bus->match_cookie;
2816 if (bus->bus_client) {
2818 if (!bus->is_kernel) {
2819 /* When this is not a kernel transport, we
2820 * store the original match string, so that we
2821 * can use it to remove the match again */
2823 s->match_callback.match_string = strdup(match);
2824 if (!s->match_callback.match_string) {
2830 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2835 bus->match_callbacks_modified = true;
2836 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2845 bus_match_parse_free(components, n_components);
2846 sd_bus_slot_unref(s);
2851 int bus_remove_match_by_string(
2854 sd_bus_message_handler_t callback,
2857 struct bus_match_component *components = NULL;
2858 unsigned n_components = 0;
2859 struct match_callback *c;
2862 assert_return(bus, -EINVAL);
2863 assert_return(match, -EINVAL);
2864 assert_return(!bus_pid_changed(bus), -ECHILD);
2866 r = bus_match_parse(match, &components, &n_components);
2870 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2874 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2877 bus_match_parse_free(components, n_components);
2882 bool bus_pid_changed(sd_bus *bus) {
2885 /* We don't support people creating a bus connection and
2886 * keeping it around over a fork(). Let's complain. */
2888 return bus->original_pid != getpid();
2891 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2892 sd_bus *bus = userdata;
2897 r = sd_bus_process(bus, NULL);
2904 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2905 sd_bus *bus = userdata;
2910 r = sd_bus_process(bus, NULL);
2917 static int prepare_callback(sd_event_source *s, void *userdata) {
2918 sd_bus *bus = userdata;
2925 e = sd_bus_get_events(bus);
2929 if (bus->output_fd != bus->input_fd) {
2931 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2935 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2939 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2944 r = sd_bus_get_timeout(bus, &until);
2950 j = sd_event_source_set_time(bus->time_event_source, until);
2955 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2962 static int quit_callback(sd_event_source *event, void *userdata) {
2963 sd_bus *bus = userdata;
2973 static int attach_io_events(sd_bus *bus) {
2978 if (bus->input_fd < 0)
2984 if (!bus->input_io_event_source) {
2985 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2989 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2993 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2995 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3000 if (bus->output_fd != bus->input_fd) {
3001 assert(bus->output_fd >= 0);
3003 if (!bus->output_io_event_source) {
3004 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3008 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3010 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3019 static void detach_io_events(sd_bus *bus) {
3022 if (bus->input_io_event_source) {
3023 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3024 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3027 if (bus->output_io_event_source) {
3028 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3029 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3033 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3036 assert_return(bus, -EINVAL);
3037 assert_return(!bus->event, -EBUSY);
3039 assert(!bus->input_io_event_source);
3040 assert(!bus->output_io_event_source);
3041 assert(!bus->time_event_source);
3044 bus->event = sd_event_ref(event);
3046 r = sd_event_default(&bus->event);
3051 bus->event_priority = priority;
3053 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3057 r = sd_event_source_set_priority(bus->time_event_source, priority);
3061 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3065 r = attach_io_events(bus);
3072 sd_bus_detach_event(bus);
3076 _public_ int sd_bus_detach_event(sd_bus *bus) {
3077 assert_return(bus, -EINVAL);
3082 detach_io_events(bus);
3084 if (bus->time_event_source) {
3085 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3086 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3089 if (bus->quit_event_source) {
3090 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3091 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3094 bus->event = sd_event_unref(bus->event);
3098 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3099 assert_return(bus, NULL);
3104 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3105 assert_return(bus, NULL);
3107 return bus->current_message;
3110 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3111 assert_return(bus, NULL);
3113 return bus->current_slot;
3116 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3121 assert(default_bus);
3124 return !!*default_bus;
3127 *ret = sd_bus_ref(*default_bus);
3135 b->default_bus_ptr = default_bus;
3143 _public_ int sd_bus_default_system(sd_bus **ret) {
3144 static thread_local sd_bus *default_system_bus = NULL;
3146 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3149 _public_ int sd_bus_default_user(sd_bus **ret) {
3150 static thread_local sd_bus *default_user_bus = NULL;
3152 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3155 _public_ int sd_bus_default(sd_bus **ret) {
3159 /* Let's try our best to reuse another cached connection. If
3160 * the starter bus type is set, connect via our normal
3161 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3162 * we can share the connection with the user/system default
3165 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3167 if (streq(e, "system"))
3168 return sd_bus_default_system(ret);
3169 else if (STR_IN_SET(e, "user", "session"))
3170 return sd_bus_default_user(ret);
3173 /* No type is specified, so we have not other option than to
3174 * use the starter address if it is set. */
3176 e = secure_getenv("DBUS_STARTER_ADDRESS");
3178 static thread_local sd_bus *default_starter_bus = NULL;
3180 return bus_default(sd_bus_open, &default_starter_bus, ret);
3183 /* Finally, if nothing is set use the cached connection for
3184 * the right scope */
3186 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3187 return sd_bus_default_user(ret);
3189 return sd_bus_default_system(ret);
3192 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3193 assert_return(b, -EINVAL);
3194 assert_return(tid, -EINVAL);
3195 assert_return(!bus_pid_changed(b), -ECHILD);
3203 return sd_event_get_tid(b->event, tid);
3208 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3209 _cleanup_free_ char *e = NULL;
3212 assert_return(object_path_is_valid(prefix), -EINVAL);
3213 assert_return(external_id, -EINVAL);
3214 assert_return(ret_path, -EINVAL);
3216 e = bus_label_escape(external_id);
3220 ret = strjoin(prefix, "/", e, NULL);
3228 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3232 assert_return(object_path_is_valid(path), -EINVAL);
3233 assert_return(object_path_is_valid(prefix), -EINVAL);
3234 assert_return(external_id, -EINVAL);
3236 e = object_path_startswith(path, prefix);
3238 *external_id = NULL;
3242 ret = bus_label_unescape(e);
3250 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3255 assert_return(bus, -EINVAL);
3256 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3257 assert_return(ret, -EINVAL);
3258 assert_return(!bus_pid_changed(bus), -ECHILD);
3263 if (!BUS_IS_OPEN(bus->state))
3266 if (!bus->ucred_valid && !isempty(bus->label))
3269 c = bus_creds_new();
3273 if (bus->ucred_valid) {
3274 pid = c->pid = bus->ucred.pid;
3275 c->uid = bus->ucred.uid;
3276 c->gid = bus->ucred.gid;
3278 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3281 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3282 c->label = strdup(bus->label);
3284 sd_bus_creds_unref(c);
3288 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3291 r = bus_creds_add_more(c, mask, pid, 0);
3299 _public_ int sd_bus_try_close(sd_bus *bus) {
3302 assert_return(bus, -EINVAL);
3303 assert_return(!bus_pid_changed(bus), -ECHILD);
3305 if (!bus->is_kernel)
3308 if (!BUS_IS_OPEN(bus->state))
3311 if (bus->rqueue_size > 0)
3314 if (bus->wqueue_size > 0)
3317 r = bus_kernel_try_close(bus);
3325 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3326 assert_return(bus, -EINVAL);
3327 assert_return(name, -EINVAL);
3328 assert_return(!bus_pid_changed(bus), -ECHILD);
3330 *name = bus->connection_name;