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 = NULL;
2111 bus->current_message = NULL;
2113 if (slot->floating) {
2114 bus_slot_disconnect(slot);
2115 sd_bus_slot_unref(slot);
2118 sd_bus_slot_unref(slot);
2120 return bus_maybe_reply_error(m, r, &error_buffer);
2123 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2127 if (bus->state != BUS_HELLO)
2130 /* Let's make sure the first message on the bus is the HELLO
2131 * reply. But note that we don't actually parse the message
2132 * here (we leave that to the usual handling), we just verify
2133 * we don't let any earlier msg through. */
2135 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2136 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2139 if (m->reply_cookie != 1)
2145 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2146 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2147 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2148 struct reply_callback *c;
2155 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2156 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2159 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2162 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2165 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2171 slot = container_of(c, sd_bus_slot, reply_callback);
2173 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2175 /* If the reply contained a file descriptor which we
2176 * didn't want we pass an error instead. */
2178 r = bus_message_new_synthetic_error(
2181 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2186 r = bus_seal_synthetic_message(bus, synthetic_reply);
2190 m = synthetic_reply;
2192 r = sd_bus_message_rewind(m, true);
2197 if (c->timeout != 0) {
2198 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2202 bus->current_slot = sd_bus_slot_ref(slot);
2203 bus->current_handler = c->callback;
2204 bus->current_userdata = slot->userdata;
2205 r = c->callback(bus, m, slot->userdata, &error_buffer);
2206 bus->current_userdata = NULL;
2207 bus->current_handler = NULL;
2208 bus->current_slot = NULL;
2210 if (slot->floating) {
2211 bus_slot_disconnect(slot);
2212 sd_bus_slot_unref(slot);
2215 sd_bus_slot_unref(slot);
2217 return bus_maybe_reply_error(m, r, &error_buffer);
2220 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2221 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2222 struct filter_callback *l;
2229 bus->filter_callbacks_modified = false;
2231 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2234 if (bus->filter_callbacks_modified)
2237 /* Don't run this more than once per iteration */
2238 if (l->last_iteration == bus->iteration_counter)
2241 l->last_iteration = bus->iteration_counter;
2243 r = sd_bus_message_rewind(m, true);
2247 slot = container_of(l, sd_bus_slot, filter_callback);
2249 bus->current_slot = sd_bus_slot_ref(slot);
2250 bus->current_handler = l->callback;
2251 bus->current_userdata = slot->userdata;
2252 r = l->callback(bus, m, slot->userdata, &error_buffer);
2253 bus->current_userdata = NULL;
2254 bus->current_handler = NULL;
2255 bus->current_slot = sd_bus_slot_unref(slot);
2257 r = bus_maybe_reply_error(m, r, &error_buffer);
2263 } while (bus->filter_callbacks_modified);
2268 static int process_match(sd_bus *bus, sd_bus_message *m) {
2275 bus->match_callbacks_modified = false;
2277 r = bus_match_run(bus, &bus->match_callbacks, m);
2281 } while (bus->match_callbacks_modified);
2286 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2287 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2293 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2296 if (bus->manual_peer_interface)
2299 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2302 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2305 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2308 if (streq_ptr(m->member, "Ping"))
2309 r = sd_bus_message_new_method_return(m, &reply);
2310 else if (streq_ptr(m->member, "GetMachineId")) {
2314 r = sd_id128_get_machine(&id);
2318 r = sd_bus_message_new_method_return(m, &reply);
2322 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2324 r = sd_bus_message_new_method_errorf(
2326 SD_BUS_ERROR_UNKNOWN_METHOD,
2327 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2333 r = sd_bus_send(bus, reply, NULL);
2340 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2344 /* If we got a message with a file descriptor which we didn't
2345 * want to accept, then let's drop it. How can this even
2346 * happen? For example, when the kernel queues a message into
2347 * an activatable names's queue which allows fds, and then is
2348 * delivered to us later even though we ourselves did not
2351 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2357 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2360 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2361 return 1; /* just eat it up */
2363 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2366 static int process_message(sd_bus *bus, sd_bus_message *m) {
2372 bus->current_message = m;
2373 bus->iteration_counter++;
2375 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2376 bus_message_type_to_string(m->header->type),
2377 strna(sd_bus_message_get_sender(m)),
2378 strna(sd_bus_message_get_destination(m)),
2379 strna(sd_bus_message_get_path(m)),
2380 strna(sd_bus_message_get_interface(m)),
2381 strna(sd_bus_message_get_member(m)),
2382 BUS_MESSAGE_COOKIE(m),
2384 strna(m->error.message));
2386 r = process_hello(bus, m);
2390 r = process_reply(bus, m);
2394 r = process_fd_check(bus, m);
2398 r = process_filter(bus, m);
2402 r = process_match(bus, m);
2406 r = process_builtin(bus, m);
2410 r = bus_process_object(bus, m);
2413 bus->current_message = NULL;
2417 static int dispatch_track(sd_bus *bus) {
2420 if (!bus->track_queue)
2423 bus_track_dispatch(bus->track_queue);
2427 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2428 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2432 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2434 r = process_timeout(bus);
2438 r = dispatch_wqueue(bus);
2442 r = dispatch_track(bus);
2446 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2452 r = process_message(bus, m);
2457 r = sd_bus_message_rewind(m, true);
2466 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2468 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2469 strna(sd_bus_message_get_sender(m)),
2470 strna(sd_bus_message_get_path(m)),
2471 strna(sd_bus_message_get_interface(m)),
2472 strna(sd_bus_message_get_member(m)));
2474 r = sd_bus_reply_method_errorf(
2476 SD_BUS_ERROR_UNKNOWN_OBJECT,
2477 "Unknown object '%s'.", m->path);
2491 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2492 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2493 struct reply_callback *c;
2497 assert(bus->state == BUS_CLOSING);
2499 c = hashmap_first(bus->reply_callbacks);
2501 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2504 /* First, fail all outstanding method calls */
2505 r = bus_message_new_synthetic_error(
2508 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2513 r = bus_seal_synthetic_message(bus, m);
2517 if (c->timeout != 0) {
2518 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2522 hashmap_remove(bus->reply_callbacks, &c->cookie);
2525 slot = container_of(c, sd_bus_slot, reply_callback);
2527 bus->iteration_counter++;
2529 bus->current_message = m;
2530 bus->current_slot = sd_bus_slot_ref(slot);
2531 bus->current_handler = c->callback;
2532 bus->current_userdata = slot->userdata;
2533 r = c->callback(bus, m, slot->userdata, &error_buffer);
2534 bus->current_userdata = NULL;
2535 bus->current_handler = NULL;
2536 bus->current_slot = NULL;
2537 bus->current_message = NULL;
2539 if (slot->floating) {
2540 bus_slot_disconnect(slot);
2541 sd_bus_slot_unref(slot);
2544 sd_bus_slot_unref(slot);
2546 return bus_maybe_reply_error(m, r, &error_buffer);
2549 /* Then, synthesize a Disconnected message */
2550 r = sd_bus_message_new_signal(
2553 "/org/freedesktop/DBus/Local",
2554 "org.freedesktop.DBus.Local",
2559 m->sender = "org.freedesktop.DBus.Local";
2561 r = bus_seal_synthetic_message(bus, m);
2567 bus->current_message = m;
2568 bus->iteration_counter++;
2570 r = process_filter(bus, m);
2574 r = process_match(bus, m);
2586 bus->current_message = NULL;
2591 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2592 BUS_DONT_DESTROY(bus);
2595 /* Returns 0 when we didn't do anything. This should cause the
2596 * caller to invoke sd_bus_wait() before returning the next
2597 * time. Returns > 0 when we did something, which possibly
2598 * means *ret is filled in with an unprocessed message. */
2600 assert_return(bus, -EINVAL);
2601 assert_return(!bus_pid_changed(bus), -ECHILD);
2603 /* We don't allow recursively invoking sd_bus_process(). */
2604 assert_return(!bus->current_message, -EBUSY);
2605 assert(!bus->current_slot);
2607 switch (bus->state) {
2616 r = bus_socket_process_opening(bus);
2617 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2618 bus_enter_closing(bus);
2626 case BUS_AUTHENTICATING:
2627 r = bus_socket_process_authenticating(bus);
2628 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2629 bus_enter_closing(bus);
2641 r = process_running(bus, hint_priority, priority, ret);
2642 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2643 bus_enter_closing(bus);
2653 return process_closing(bus, ret);
2656 assert_not_reached("Unknown state");
2659 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2660 return bus_process_internal(bus, false, 0, ret);
2663 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2664 return bus_process_internal(bus, true, priority, ret);
2667 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2668 struct pollfd p[2] = {};
2671 usec_t m = USEC_INFINITY;
2675 if (bus->state == BUS_CLOSING)
2678 if (!BUS_IS_OPEN(bus->state))
2681 e = sd_bus_get_events(bus);
2686 /* The caller really needs some more data, he doesn't
2687 * care about what's already read, or any timeouts
2692 /* The caller wants to process if there's something to
2693 * process, but doesn't care otherwise */
2695 r = sd_bus_get_timeout(bus, &until);
2700 nw = now(CLOCK_MONOTONIC);
2701 m = until > nw ? until - nw : 0;
2705 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2708 p[0].fd = bus->input_fd;
2709 if (bus->output_fd == bus->input_fd) {
2713 p[0].events = e & POLLIN;
2714 p[1].fd = bus->output_fd;
2715 p[1].events = e & POLLOUT;
2719 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2723 return r > 0 ? 1 : 0;
2726 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2728 assert_return(bus, -EINVAL);
2729 assert_return(!bus_pid_changed(bus), -ECHILD);
2731 if (bus->state == BUS_CLOSING)
2734 if (!BUS_IS_OPEN(bus->state))
2737 if (bus->rqueue_size > 0)
2740 return bus_poll(bus, false, timeout_usec);
2743 _public_ int sd_bus_flush(sd_bus *bus) {
2746 assert_return(bus, -EINVAL);
2747 assert_return(!bus_pid_changed(bus), -ECHILD);
2749 if (bus->state == BUS_CLOSING)
2752 if (!BUS_IS_OPEN(bus->state))
2755 r = bus_ensure_running(bus);
2759 if (bus->wqueue_size <= 0)
2763 r = dispatch_wqueue(bus);
2765 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2766 bus_enter_closing(bus);
2773 if (bus->wqueue_size <= 0)
2776 r = bus_poll(bus, false, (uint64_t) -1);
2782 _public_ int sd_bus_add_filter(
2785 sd_bus_message_handler_t callback,
2790 assert_return(bus, -EINVAL);
2791 assert_return(callback, -EINVAL);
2792 assert_return(!bus_pid_changed(bus), -ECHILD);
2794 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2798 s->filter_callback.callback = callback;
2800 bus->filter_callbacks_modified = true;
2801 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2809 _public_ int sd_bus_add_match(
2813 sd_bus_message_handler_t callback,
2816 struct bus_match_component *components = NULL;
2817 unsigned n_components = 0;
2818 sd_bus_slot *s = NULL;
2821 assert_return(bus, -EINVAL);
2822 assert_return(match, -EINVAL);
2823 assert_return(!bus_pid_changed(bus), -ECHILD);
2825 r = bus_match_parse(match, &components, &n_components);
2829 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2835 s->match_callback.callback = callback;
2836 s->match_callback.cookie = ++bus->match_cookie;
2838 if (bus->bus_client) {
2840 if (!bus->is_kernel) {
2841 /* When this is not a kernel transport, we
2842 * store the original match string, so that we
2843 * can use it to remove the match again */
2845 s->match_callback.match_string = strdup(match);
2846 if (!s->match_callback.match_string) {
2852 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2857 bus->match_callbacks_modified = true;
2858 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2867 bus_match_parse_free(components, n_components);
2868 sd_bus_slot_unref(s);
2873 int bus_remove_match_by_string(
2876 sd_bus_message_handler_t callback,
2879 struct bus_match_component *components = NULL;
2880 unsigned n_components = 0;
2881 struct match_callback *c;
2884 assert_return(bus, -EINVAL);
2885 assert_return(match, -EINVAL);
2886 assert_return(!bus_pid_changed(bus), -ECHILD);
2888 r = bus_match_parse(match, &components, &n_components);
2892 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2896 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2899 bus_match_parse_free(components, n_components);
2904 bool bus_pid_changed(sd_bus *bus) {
2907 /* We don't support people creating a bus connection and
2908 * keeping it around over a fork(). Let's complain. */
2910 return bus->original_pid != getpid();
2913 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2914 sd_bus *bus = userdata;
2919 r = sd_bus_process(bus, NULL);
2926 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2927 sd_bus *bus = userdata;
2932 r = sd_bus_process(bus, NULL);
2939 static int prepare_callback(sd_event_source *s, void *userdata) {
2940 sd_bus *bus = userdata;
2947 e = sd_bus_get_events(bus);
2951 if (bus->output_fd != bus->input_fd) {
2953 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2957 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2961 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2966 r = sd_bus_get_timeout(bus, &until);
2972 j = sd_event_source_set_time(bus->time_event_source, until);
2977 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2984 static int quit_callback(sd_event_source *event, void *userdata) {
2985 sd_bus *bus = userdata;
2995 static int attach_io_events(sd_bus *bus) {
3000 if (bus->input_fd < 0)
3006 if (!bus->input_io_event_source) {
3007 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3011 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3015 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3019 r = sd_event_source_set_name(bus->input_io_event_source, "bus-input");
3021 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3026 if (bus->output_fd != bus->input_fd) {
3027 assert(bus->output_fd >= 0);
3029 if (!bus->output_io_event_source) {
3030 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3034 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3038 r = sd_event_source_set_name(bus->input_io_event_source, "bus-output");
3040 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3049 static void detach_io_events(sd_bus *bus) {
3052 if (bus->input_io_event_source) {
3053 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3054 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3057 if (bus->output_io_event_source) {
3058 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3059 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3063 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3066 assert_return(bus, -EINVAL);
3067 assert_return(!bus->event, -EBUSY);
3069 assert(!bus->input_io_event_source);
3070 assert(!bus->output_io_event_source);
3071 assert(!bus->time_event_source);
3074 bus->event = sd_event_ref(event);
3076 r = sd_event_default(&bus->event);
3081 bus->event_priority = priority;
3083 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3087 r = sd_event_source_set_priority(bus->time_event_source, priority);
3091 r = sd_event_source_set_name(bus->time_event_source, "bus-time");
3095 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3099 r = sd_event_source_set_name(bus->quit_event_source, "bus-exit");
3103 r = attach_io_events(bus);
3110 sd_bus_detach_event(bus);
3114 _public_ int sd_bus_detach_event(sd_bus *bus) {
3115 assert_return(bus, -EINVAL);
3120 detach_io_events(bus);
3122 if (bus->time_event_source) {
3123 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3124 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3127 if (bus->quit_event_source) {
3128 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3129 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3132 bus->event = sd_event_unref(bus->event);
3136 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3137 assert_return(bus, NULL);
3142 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3143 assert_return(bus, NULL);
3145 return bus->current_message;
3148 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3149 assert_return(bus, NULL);
3151 return bus->current_slot;
3154 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3155 assert_return(bus, NULL);
3157 return bus->current_handler;
3160 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3161 assert_return(bus, NULL);
3163 return bus->current_userdata;
3166 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3171 assert(default_bus);
3174 return !!*default_bus;
3177 *ret = sd_bus_ref(*default_bus);
3185 b->default_bus_ptr = default_bus;
3193 _public_ int sd_bus_default_system(sd_bus **ret) {
3194 static thread_local sd_bus *default_system_bus = NULL;
3196 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3199 _public_ int sd_bus_default_user(sd_bus **ret) {
3200 static thread_local sd_bus *default_user_bus = NULL;
3202 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3205 _public_ int sd_bus_default(sd_bus **ret) {
3209 /* Let's try our best to reuse another cached connection. If
3210 * the starter bus type is set, connect via our normal
3211 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3212 * we can share the connection with the user/system default
3215 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3217 if (streq(e, "system"))
3218 return sd_bus_default_system(ret);
3219 else if (STR_IN_SET(e, "user", "session"))
3220 return sd_bus_default_user(ret);
3223 /* No type is specified, so we have not other option than to
3224 * use the starter address if it is set. */
3226 e = secure_getenv("DBUS_STARTER_ADDRESS");
3228 static thread_local sd_bus *default_starter_bus = NULL;
3230 return bus_default(sd_bus_open, &default_starter_bus, ret);
3233 /* Finally, if nothing is set use the cached connection for
3234 * the right scope */
3236 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3237 return sd_bus_default_user(ret);
3239 return sd_bus_default_system(ret);
3242 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3243 assert_return(b, -EINVAL);
3244 assert_return(tid, -EINVAL);
3245 assert_return(!bus_pid_changed(b), -ECHILD);
3253 return sd_event_get_tid(b->event, tid);
3258 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3259 _cleanup_free_ char *e = NULL;
3262 assert_return(object_path_is_valid(prefix), -EINVAL);
3263 assert_return(external_id, -EINVAL);
3264 assert_return(ret_path, -EINVAL);
3266 e = bus_label_escape(external_id);
3270 ret = strjoin(prefix, "/", e, NULL);
3278 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3282 assert_return(object_path_is_valid(path), -EINVAL);
3283 assert_return(object_path_is_valid(prefix), -EINVAL);
3284 assert_return(external_id, -EINVAL);
3286 e = object_path_startswith(path, prefix);
3288 *external_id = NULL;
3292 ret = bus_label_unescape(e);
3300 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3305 assert_return(bus, -EINVAL);
3306 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3307 assert_return(ret, -EINVAL);
3308 assert_return(!bus_pid_changed(bus), -ECHILD);
3313 if (!BUS_IS_OPEN(bus->state))
3316 if (!bus->ucred_valid && !isempty(bus->label))
3319 c = bus_creds_new();
3323 if (bus->ucred_valid) {
3324 pid = c->pid = bus->ucred.pid;
3325 c->uid = bus->ucred.uid;
3326 c->gid = bus->ucred.gid;
3328 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3331 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3332 c->label = strdup(bus->label);
3334 sd_bus_creds_unref(c);
3338 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3341 r = bus_creds_add_more(c, mask, pid, 0);
3349 _public_ int sd_bus_try_close(sd_bus *bus) {
3352 assert_return(bus, -EINVAL);
3353 assert_return(!bus_pid_changed(bus), -ECHILD);
3355 if (!bus->is_kernel)
3358 if (!BUS_IS_OPEN(bus->state))
3361 if (bus->rqueue_size > 0)
3364 if (bus->wqueue_size > 0)
3367 r = bus_kernel_try_close(bus);
3375 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3376 assert_return(bus, -EINVAL);
3377 assert_return(name, -EINVAL);
3378 assert_return(!bus_pid_changed(bus), -ECHILD);
3380 *name = bus->connection_name;
3384 int bus_get_root_path(sd_bus *bus) {
3387 if (bus->cgroup_root)
3390 r = cg_get_root_path(&bus->cgroup_root);
3392 bus->cgroup_root = strdup("/");
3393 if (!bus->cgroup_root)