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 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
146 bus_match_free(&b->match_callbacks);
148 hashmap_free_free(b->vtable_methods);
149 hashmap_free_free(b->vtable_properties);
151 assert(hashmap_isempty(b->nodes));
152 hashmap_free(b->nodes);
154 bus_kernel_flush_memfd(b);
156 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
161 _public_ int sd_bus_new(sd_bus **ret) {
164 assert_return(ret, -EINVAL);
170 r->n_ref = REFCNT_INIT;
171 r->input_fd = r->output_fd = -1;
172 r->message_version = 1;
173 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
174 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
175 r->attach_flags |= KDBUS_ATTACH_NAMES;
176 r->original_pid = getpid();
178 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
180 /* We guarantee that wqueue always has space for at least one
182 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
191 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
194 assert_return(bus, -EINVAL);
195 assert_return(bus->state == BUS_UNSET, -EPERM);
196 assert_return(address, -EINVAL);
197 assert_return(!bus_pid_changed(bus), -ECHILD);
209 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
210 assert_return(bus, -EINVAL);
211 assert_return(bus->state == BUS_UNSET, -EPERM);
212 assert_return(input_fd >= 0, -EINVAL);
213 assert_return(output_fd >= 0, -EINVAL);
214 assert_return(!bus_pid_changed(bus), -ECHILD);
216 bus->input_fd = input_fd;
217 bus->output_fd = output_fd;
221 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
224 assert_return(bus, -EINVAL);
225 assert_return(bus->state == BUS_UNSET, -EPERM);
226 assert_return(path, -EINVAL);
227 assert_return(!strv_isempty(argv), -EINVAL);
228 assert_return(!bus_pid_changed(bus), -ECHILD);
240 free(bus->exec_path);
241 strv_free(bus->exec_argv);
249 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
250 assert_return(bus, -EINVAL);
251 assert_return(bus->state == BUS_UNSET, -EPERM);
252 assert_return(!bus_pid_changed(bus), -ECHILD);
254 bus->bus_client = !!b;
258 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
259 assert_return(bus, -EINVAL);
260 assert_return(bus->state == BUS_UNSET, -EPERM);
261 assert_return(!bus_pid_changed(bus), -ECHILD);
263 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
267 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
268 assert_return(bus, -EINVAL);
269 assert_return(bus->state == BUS_UNSET, -EPERM);
270 assert_return(!bus_pid_changed(bus), -ECHILD);
272 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
276 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
277 assert_return(bus, -EINVAL);
278 assert_return(bus->state == BUS_UNSET, -EPERM);
279 assert_return(!bus_pid_changed(bus), -ECHILD);
281 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
285 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
286 assert_return(bus, -EINVAL);
287 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
288 assert_return(bus->state == BUS_UNSET, -EPERM);
289 assert_return(!bus_pid_changed(bus), -ECHILD);
291 /* The well knowns we need unconditionally, so that matches can work */
292 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
294 return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags);
297 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
298 assert_return(bus, -EINVAL);
299 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
300 assert_return(bus->state == BUS_UNSET, -EPERM);
301 assert_return(!bus_pid_changed(bus), -ECHILD);
303 bus->is_server = !!b;
304 bus->server_id = server_id;
308 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
309 assert_return(bus, -EINVAL);
310 assert_return(bus->state == BUS_UNSET, -EPERM);
311 assert_return(!bus_pid_changed(bus), -ECHILD);
313 bus->anonymous_auth = !!b;
317 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
318 assert_return(bus, -EINVAL);
319 assert_return(bus->state == BUS_UNSET, -EPERM);
320 assert_return(!bus_pid_changed(bus), -ECHILD);
326 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
329 assert_return(bus, -EINVAL);
330 assert_return(name, -EINVAL);
331 assert_return(bus->state == BUS_UNSET, -EPERM);
332 assert_return(!bus_pid_changed(bus), -ECHILD);
338 free(bus->connection_name);
339 bus->connection_name = n;
344 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
349 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
352 r = sd_bus_message_get_errno(reply);
356 r = sd_bus_message_read(reply, "s", &s);
360 if (!service_name_is_valid(s) || s[0] != ':')
363 bus->unique_name = strdup(s);
364 if (!bus->unique_name)
367 if (bus->state == BUS_HELLO)
368 bus->state = BUS_RUNNING;
373 static int bus_send_hello(sd_bus *bus) {
374 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
379 if (!bus->bus_client || bus->is_kernel)
382 r = sd_bus_message_new_method_call(
385 "org.freedesktop.DBus",
386 "/org/freedesktop/DBus",
387 "org.freedesktop.DBus",
392 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
395 int bus_start_running(sd_bus *bus) {
398 if (bus->bus_client && !bus->is_kernel) {
399 bus->state = BUS_HELLO;
403 bus->state = BUS_RUNNING;
407 static int parse_address_key(const char **p, const char *key, char **value) {
408 size_t l, n = 0, allocated = 0;
418 if (strncmp(*p, key, l) != 0)
431 while (*a != ';' && *a != ',' && *a != 0) {
449 c = (char) ((x << 4) | y);
456 if (!GREEDY_REALLOC(r, allocated, n + 2))
480 static void skip_address_key(const char **p) {
484 *p += strcspn(*p, ",");
490 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
491 _cleanup_free_ char *path = NULL, *abstract = NULL;
500 while (**p != 0 && **p != ';') {
501 r = parse_address_key(p, "guid", guid);
507 r = parse_address_key(p, "path", &path);
513 r = parse_address_key(p, "abstract", &abstract);
522 if (!path && !abstract)
525 if (path && abstract)
530 if (l > sizeof(b->sockaddr.un.sun_path))
533 b->sockaddr.un.sun_family = AF_UNIX;
534 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
535 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
536 } else if (abstract) {
537 l = strlen(abstract);
538 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
541 b->sockaddr.un.sun_family = AF_UNIX;
542 b->sockaddr.un.sun_path[0] = 0;
543 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
544 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
550 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
551 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
553 struct addrinfo *result, hints = {
554 .ai_socktype = SOCK_STREAM,
555 .ai_flags = AI_ADDRCONFIG,
563 while (**p != 0 && **p != ';') {
564 r = parse_address_key(p, "guid", guid);
570 r = parse_address_key(p, "host", &host);
576 r = parse_address_key(p, "port", &port);
582 r = parse_address_key(p, "family", &family);
595 if (streq(family, "ipv4"))
596 hints.ai_family = AF_INET;
597 else if (streq(family, "ipv6"))
598 hints.ai_family = AF_INET6;
603 r = getaddrinfo(host, port, &hints, &result);
607 return -EADDRNOTAVAIL;
609 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
610 b->sockaddr_size = result->ai_addrlen;
612 freeaddrinfo(result);
617 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
619 unsigned n_argv = 0, j;
621 size_t allocated = 0;
629 while (**p != 0 && **p != ';') {
630 r = parse_address_key(p, "guid", guid);
636 r = parse_address_key(p, "path", &path);
642 if (startswith(*p, "argv")) {
646 ul = strtoul(*p + 4, (char**) p, 10);
647 if (errno > 0 || **p != '=' || ul > 256) {
655 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
663 r = parse_address_key(p, NULL, argv + ul);
678 /* Make sure there are no holes in the array, with the
679 * exception of argv[0] */
680 for (j = 1; j < n_argv; j++)
686 if (argv && argv[0] == NULL) {
687 argv[0] = strdup(path);
699 for (j = 0; j < n_argv; j++)
707 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
708 _cleanup_free_ char *path = NULL;
716 while (**p != 0 && **p != ';') {
717 r = parse_address_key(p, "guid", guid);
723 r = parse_address_key(p, "path", &path);
742 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
743 _cleanup_free_ char *machine = NULL;
751 while (**p != 0 && **p != ';') {
752 r = parse_address_key(p, "guid", guid);
758 r = parse_address_key(p, "machine", &machine);
770 if (!filename_is_safe(machine))
774 b->machine = machine;
777 b->sockaddr.un.sun_family = AF_UNIX;
778 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
779 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
784 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
785 _cleanup_free_ char *machine = NULL;
793 while (**p != 0 && **p != ';') {
794 r = parse_address_key(p, "guid", guid);
800 r = parse_address_key(p, "machine", &machine);
812 if (!filename_is_safe(machine))
816 b->machine = machine;
820 b->kernel = strdup("/dev/kdbus/0-system/bus");
827 static void bus_reset_parsed_address(sd_bus *b) {
831 b->sockaddr_size = 0;
832 strv_free(b->exec_argv);
836 b->server_id = SD_ID128_NULL;
843 static int bus_parse_next_address(sd_bus *b) {
844 _cleanup_free_ char *guid = NULL;
852 if (b->address[b->address_index] == 0)
855 bus_reset_parsed_address(b);
857 a = b->address + b->address_index;
866 if (startswith(a, "unix:")) {
869 r = parse_unix_address(b, &a, &guid);
874 } else if (startswith(a, "tcp:")) {
877 r = parse_tcp_address(b, &a, &guid);
883 } else if (startswith(a, "unixexec:")) {
886 r = parse_exec_address(b, &a, &guid);
892 } else if (startswith(a, "kernel:")) {
895 r = parse_kernel_address(b, &a, &guid);
900 } else if (startswith(a, "x-container-unix:")) {
903 r = parse_container_unix_address(b, &a, &guid);
908 } else if (startswith(a, "x-container-kernel:")) {
911 r = parse_container_kernel_address(b, &a, &guid);
924 r = sd_id128_from_string(guid, &b->server_id);
929 b->address_index = a - b->address;
933 static int bus_start_address(sd_bus *b) {
939 bool skipped = false;
944 r = bus_socket_exec(b);
945 else if (b->machine && b->kernel)
946 r = bus_container_connect_kernel(b);
947 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
948 r = bus_container_connect_socket(b);
950 r = bus_kernel_connect(b);
951 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
952 r = bus_socket_connect(b);
958 r = attach_io_events(b);
963 b->last_connect_error = -r;
966 r = bus_parse_next_address(b);
970 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
974 int bus_next_address(sd_bus *b) {
977 bus_reset_parsed_address(b);
978 return bus_start_address(b);
981 static int bus_start_fd(sd_bus *b) {
986 assert(b->input_fd >= 0);
987 assert(b->output_fd >= 0);
989 r = fd_nonblock(b->input_fd, true);
993 r = fd_cloexec(b->input_fd, true);
997 if (b->input_fd != b->output_fd) {
998 r = fd_nonblock(b->output_fd, true);
1002 r = fd_cloexec(b->output_fd, true);
1007 if (fstat(b->input_fd, &st) < 0)
1010 if (S_ISCHR(b->input_fd))
1011 return bus_kernel_take_fd(b);
1013 return bus_socket_take_fd(b);
1016 _public_ int sd_bus_start(sd_bus *bus) {
1019 assert_return(bus, -EINVAL);
1020 assert_return(bus->state == BUS_UNSET, -EPERM);
1021 assert_return(!bus_pid_changed(bus), -ECHILD);
1023 bus->state = BUS_OPENING;
1025 if (bus->is_server && bus->bus_client)
1028 if (bus->input_fd >= 0)
1029 r = bus_start_fd(bus);
1030 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1031 r = bus_start_address(bus);
1040 return bus_send_hello(bus);
1043 _public_ int sd_bus_open(sd_bus **ret) {
1048 assert_return(ret, -EINVAL);
1050 /* Let's connect to the starter bus if it is set, and
1051 * otherwise to the bus that is appropropriate for the scope
1052 * we are running in */
1054 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1056 if (streq(e, "system"))
1057 return sd_bus_open_system(ret);
1058 else if (STR_IN_SET(e, "session", "user"))
1059 return sd_bus_open_user(ret);
1062 e = secure_getenv("DBUS_STARTER_ADDRESS");
1064 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1065 return sd_bus_open_user(ret);
1067 return sd_bus_open_system(ret);
1074 r = sd_bus_set_address(b, e);
1078 b->bus_client = true;
1080 /* We don't know whether the bus is trusted or not, so better
1081 * be safe, and authenticate everything */
1083 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1085 r = sd_bus_start(b);
1097 int bus_set_address_system(sd_bus *b) {
1101 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1103 return sd_bus_set_address(b, e);
1105 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1108 _public_ int sd_bus_open_system(sd_bus **ret) {
1112 assert_return(ret, -EINVAL);
1118 r = bus_set_address_system(b);
1122 b->bus_client = true;
1123 b->is_system = true;
1125 /* Let's do per-method access control on the system bus. We
1126 * need the caller's UID and capability set for that. */
1128 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1130 r = sd_bus_start(b);
1142 int bus_set_address_user(sd_bus *b) {
1147 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1149 return sd_bus_set_address(b, e);
1151 e = secure_getenv("XDG_RUNTIME_DIR");
1153 _cleanup_free_ char *ee = NULL;
1155 ee = bus_address_escape(e);
1160 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1162 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1168 r = asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1172 return -ECONNREFUSED;
1182 _public_ int sd_bus_open_user(sd_bus **ret) {
1186 assert_return(ret, -EINVAL);
1192 r = bus_set_address_user(b);
1196 b->bus_client = true;
1199 /* We don't do any per-method access control on the user
1203 r = sd_bus_start(b);
1215 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1216 _cleanup_free_ char *e = NULL;
1217 char *m = NULL, *c = NULL;
1222 /* Let's see if we shall enter some container */
1223 m = strchr(host, ':');
1227 /* Let's make sure this is not a port of some kind,
1228 * and is a valid machine name. */
1229 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1232 /* Cut out the host part */
1233 t = strndupa(host, m - host - 1);
1234 e = bus_address_escape(t);
1238 c = strappenda(",argv4=--machine=", m);
1243 e = bus_address_escape(host);
1248 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1255 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1259 assert_return(host, -EINVAL);
1260 assert_return(ret, -EINVAL);
1262 r = sd_bus_new(&bus);
1266 r = bus_set_address_system_remote(bus, host);
1270 bus->bus_client = true;
1271 bus->trusted = false;
1273 r = sd_bus_start(bus);
1285 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1286 _cleanup_free_ char *e = NULL;
1291 e = bus_address_escape(machine);
1296 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1298 b->address = strjoin("x-container-unix:machine=", e, NULL);
1306 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1310 assert_return(machine, -EINVAL);
1311 assert_return(ret, -EINVAL);
1312 assert_return(filename_is_safe(machine), -EINVAL);
1314 r = sd_bus_new(&bus);
1318 r = bus_set_address_system_container(bus, machine);
1322 bus->bus_client = true;
1323 bus->trusted = false;
1325 r = sd_bus_start(bus);
1337 _public_ void sd_bus_close(sd_bus *bus) {
1341 if (bus->state == BUS_CLOSED)
1343 if (bus_pid_changed(bus))
1346 bus->state = BUS_CLOSED;
1348 sd_bus_detach_event(bus);
1350 /* Drop all queued messages so that they drop references to
1351 * the bus object and the bus may be freed */
1352 bus_reset_queues(bus);
1354 if (!bus->is_kernel)
1357 /* We'll leave the fd open in case this is a kernel bus, since
1358 * there might still be memblocks around that reference this
1359 * bus, and they might need to invoke the KDBUS_CMD_FREE
1360 * ioctl on the fd when they are freed. */
1363 static void bus_enter_closing(sd_bus *bus) {
1366 if (bus->state != BUS_OPENING &&
1367 bus->state != BUS_AUTHENTICATING &&
1368 bus->state != BUS_HELLO &&
1369 bus->state != BUS_RUNNING)
1372 bus->state = BUS_CLOSING;
1375 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1376 assert_return(bus, NULL);
1378 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1383 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1389 i = REFCNT_DEC(bus->n_ref);
1397 _public_ int sd_bus_is_open(sd_bus *bus) {
1399 assert_return(bus, -EINVAL);
1400 assert_return(!bus_pid_changed(bus), -ECHILD);
1402 return BUS_IS_OPEN(bus->state);
1405 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1408 assert_return(bus, -EINVAL);
1409 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1410 assert_return(!bus_pid_changed(bus), -ECHILD);
1412 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1415 if (type == SD_BUS_TYPE_UNIX_FD) {
1416 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1419 r = bus_ensure_running(bus);
1423 return bus->can_fds;
1426 return bus_type_is_valid(type);
1429 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1432 assert_return(bus, -EINVAL);
1433 assert_return(server_id, -EINVAL);
1434 assert_return(!bus_pid_changed(bus), -ECHILD);
1436 r = bus_ensure_running(bus);
1440 *server_id = bus->server_id;
1444 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1449 /* If we copy the same message to multiple
1450 * destinations, avoid using the same cookie
1452 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1457 timeout = BUS_DEFAULT_TIMEOUT;
1459 return bus_message_seal(m, ++b->cookie, timeout);
1462 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1465 /* Do packet version and endianness already match? */
1466 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1467 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1470 /* No? Then remarshal! */
1471 return bus_message_remarshal(b, m);
1474 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1478 /* The bus specification says the serial number cannot be 0,
1479 * hence let's fill something in for synthetic messages. Since
1480 * synthetic messages might have a fake sender and we don't
1481 * want to interfere with the real sender's serial numbers we
1482 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1483 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1484 * even though kdbus can do 64bit. */
1486 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1489 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1496 r = bus_kernel_write_message(bus, m, hint_sync_call);
1498 r = bus_socket_write_message(bus, m, idx);
1503 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1504 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1505 bus_message_type_to_string(m->header->type),
1506 strna(sd_bus_message_get_sender(m)),
1507 strna(sd_bus_message_get_destination(m)),
1508 strna(sd_bus_message_get_path(m)),
1509 strna(sd_bus_message_get_interface(m)),
1510 strna(sd_bus_message_get_member(m)),
1511 BUS_MESSAGE_COOKIE(m),
1513 strna(m->error.message));
1518 static int dispatch_wqueue(sd_bus *bus) {
1522 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1524 while (bus->wqueue_size > 0) {
1526 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1530 /* Didn't do anything this time */
1532 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1533 /* Fully written. Let's drop the entry from
1536 * This isn't particularly optimized, but
1537 * well, this is supposed to be our worst-case
1538 * buffer only, and the socket buffer is
1539 * supposed to be our primary buffer, and if
1540 * it got full, then all bets are off
1543 bus->wqueue_size --;
1544 sd_bus_message_unref(bus->wqueue[0]);
1545 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1555 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1559 return bus_kernel_read_message(bus, hint_priority, priority);
1561 return bus_socket_read_message(bus);
1564 int bus_rqueue_make_room(sd_bus *bus) {
1567 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1570 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1576 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1581 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1583 /* Note that the priority logic is only available on kdbus,
1584 * where the rqueue is unused. We check the rqueue here
1585 * anyway, because it's simple... */
1588 if (bus->rqueue_size > 0) {
1589 /* Dispatch a queued message */
1591 *m = bus->rqueue[0];
1592 bus->rqueue_size --;
1593 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1597 /* Try to read a new message */
1598 r = bus_read_message(bus, hint_priority, priority);
1608 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1609 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1612 assert_return(bus, -EINVAL);
1613 assert_return(m, -EINVAL);
1614 assert_return(!bus_pid_changed(bus), -ECHILD);
1615 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1617 if (!BUS_IS_OPEN(bus->state))
1621 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1628 /* If the cookie number isn't kept, then we know that no reply
1630 if (!cookie && !m->sealed)
1631 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1633 r = bus_seal_message(bus, m, 0);
1637 /* Remarshall if we have to. This will possibly unref the
1638 * message and place a replacement in m */
1639 r = bus_remarshal_message(bus, &m);
1643 /* If this is a reply and no reply was requested, then let's
1644 * suppress this, if we can */
1645 if (m->dont_send && !cookie)
1648 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1651 r = bus_write_message(bus, m, hint_sync_call, &idx);
1653 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1654 bus_enter_closing(bus);
1659 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1660 /* Wasn't fully written. So let's remember how
1661 * much was written. Note that the first entry
1662 * of the wqueue array is always allocated so
1663 * that we always can remember how much was
1665 bus->wqueue[0] = sd_bus_message_ref(m);
1666 bus->wqueue_size = 1;
1670 /* Just append it to the queue. */
1672 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1675 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1678 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1682 *cookie = BUS_MESSAGE_COOKIE(m);
1687 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1688 return bus_send_internal(bus, m, cookie, false);
1691 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1694 assert_return(bus, -EINVAL);
1695 assert_return(m, -EINVAL);
1696 assert_return(!bus_pid_changed(bus), -ECHILD);
1698 if (!BUS_IS_OPEN(bus->state))
1701 if (!streq_ptr(m->destination, destination)) {
1706 r = sd_bus_message_set_destination(m, destination);
1711 return sd_bus_send(bus, m, cookie);
1714 static usec_t calc_elapse(uint64_t usec) {
1715 if (usec == (uint64_t) -1)
1718 return now(CLOCK_MONOTONIC) + usec;
1721 static int timeout_compare(const void *a, const void *b) {
1722 const struct reply_callback *x = a, *y = b;
1724 if (x->timeout != 0 && y->timeout == 0)
1727 if (x->timeout == 0 && y->timeout != 0)
1730 if (x->timeout < y->timeout)
1733 if (x->timeout > y->timeout)
1739 _public_ int sd_bus_call_async(
1743 sd_bus_message_handler_t callback,
1747 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1748 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1751 assert_return(bus, -EINVAL);
1752 assert_return(m, -EINVAL);
1753 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1754 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1755 assert_return(callback, -EINVAL);
1756 assert_return(!bus_pid_changed(bus), -ECHILD);
1757 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1759 if (!BUS_IS_OPEN(bus->state))
1762 r = hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1766 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1770 r = bus_seal_message(bus, m, usec);
1774 r = bus_remarshal_message(bus, &m);
1778 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1782 s->reply_callback.callback = callback;
1784 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1785 r = hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1787 s->reply_callback.cookie = 0;
1791 s->reply_callback.timeout = calc_elapse(m->timeout);
1792 if (s->reply_callback.timeout != 0) {
1793 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1795 s->reply_callback.timeout = 0;
1800 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1811 int bus_ensure_running(sd_bus *bus) {
1816 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1818 if (bus->state == BUS_RUNNING)
1822 r = sd_bus_process(bus, NULL);
1825 if (bus->state == BUS_RUNNING)
1830 r = sd_bus_wait(bus, (uint64_t) -1);
1836 _public_ int sd_bus_call(
1840 sd_bus_error *error,
1841 sd_bus_message **reply) {
1843 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1849 assert_return(bus, -EINVAL);
1850 assert_return(m, -EINVAL);
1851 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1852 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1853 assert_return(!bus_error_is_dirty(error), -EINVAL);
1854 assert_return(!bus_pid_changed(bus), -ECHILD);
1855 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1857 if (!BUS_IS_OPEN(bus->state))
1860 r = bus_ensure_running(bus);
1864 i = bus->rqueue_size;
1866 r = bus_seal_message(bus, m, usec);
1870 r = bus_remarshal_message(bus, &m);
1874 r = bus_send_internal(bus, m, &cookie, true);
1878 timeout = calc_elapse(m->timeout);
1883 while (i < bus->rqueue_size) {
1884 sd_bus_message *incoming = NULL;
1886 incoming = bus->rqueue[i];
1888 if (incoming->reply_cookie == cookie) {
1889 /* Found a match! */
1891 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1894 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1896 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1900 sd_bus_message_unref(incoming);
1905 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1907 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1908 r = sd_bus_error_copy(error, &incoming->error);
1912 sd_bus_message_unref(incoming);
1915 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1918 streq(bus->unique_name, incoming->sender)) {
1920 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1923 /* Our own message? Somebody is trying
1924 * to send its own client a message,
1925 * let's not dead-lock, let's fail
1928 sd_bus_message_unref(incoming);
1932 /* Try to read more, right-away */
1936 r = bus_read_message(bus, false, 0);
1938 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1939 bus_enter_closing(bus);
1951 n = now(CLOCK_MONOTONIC);
1957 left = (uint64_t) -1;
1959 r = bus_poll(bus, true, left);
1965 r = dispatch_wqueue(bus);
1967 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1968 bus_enter_closing(bus);
1977 _public_ int sd_bus_get_fd(sd_bus *bus) {
1979 assert_return(bus, -EINVAL);
1980 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1981 assert_return(!bus_pid_changed(bus), -ECHILD);
1983 return bus->input_fd;
1986 _public_ int sd_bus_get_events(sd_bus *bus) {
1989 assert_return(bus, -EINVAL);
1990 assert_return(!bus_pid_changed(bus), -ECHILD);
1992 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1995 if (bus->state == BUS_OPENING)
1997 else if (bus->state == BUS_AUTHENTICATING) {
1999 if (bus_socket_auth_needs_write(bus))
2004 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2005 if (bus->rqueue_size <= 0)
2007 if (bus->wqueue_size > 0)
2014 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2015 struct reply_callback *c;
2017 assert_return(bus, -EINVAL);
2018 assert_return(timeout_usec, -EINVAL);
2019 assert_return(!bus_pid_changed(bus), -ECHILD);
2021 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2024 if (bus->track_queue) {
2029 if (bus->state == BUS_CLOSING) {
2034 if (bus->state == BUS_AUTHENTICATING) {
2035 *timeout_usec = bus->auth_timeout;
2039 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2040 *timeout_usec = (uint64_t) -1;
2044 if (bus->rqueue_size > 0) {
2049 c = prioq_peek(bus->reply_callbacks_prioq);
2051 *timeout_usec = (uint64_t) -1;
2055 if (c->timeout == 0) {
2056 *timeout_usec = (uint64_t) -1;
2060 *timeout_usec = c->timeout;
2064 static int process_timeout(sd_bus *bus) {
2065 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2066 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2067 struct reply_callback *c;
2074 c = prioq_peek(bus->reply_callbacks_prioq);
2078 n = now(CLOCK_MONOTONIC);
2082 r = bus_message_new_synthetic_error(
2085 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2090 m->sender = "org.freedesktop.DBus";
2092 r = bus_seal_synthetic_message(bus, m);
2096 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2099 hashmap_remove(bus->reply_callbacks, &c->cookie);
2102 slot = container_of(c, sd_bus_slot, reply_callback);
2104 bus->iteration_counter ++;
2106 bus->current_message = m;
2107 bus->current_slot = sd_bus_slot_ref(slot);
2108 bus->current_handler = c->callback;
2109 bus->current_userdata = slot->userdata;
2110 r = c->callback(bus, m, slot->userdata, &error_buffer);
2111 bus->current_userdata = NULL;
2112 bus->current_handler = NULL;
2113 bus->current_slot = NULL;
2114 bus->current_message = NULL;
2116 if (slot->floating) {
2117 bus_slot_disconnect(slot);
2118 sd_bus_slot_unref(slot);
2121 sd_bus_slot_unref(slot);
2123 return bus_maybe_reply_error(m, r, &error_buffer);
2126 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2130 if (bus->state != BUS_HELLO)
2133 /* Let's make sure the first message on the bus is the HELLO
2134 * reply. But note that we don't actually parse the message
2135 * here (we leave that to the usual handling), we just verify
2136 * we don't let any earlier msg through. */
2138 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2139 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2142 if (m->reply_cookie != 1)
2148 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2149 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2150 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2151 struct reply_callback *c;
2158 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2159 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2162 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2165 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2168 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2174 slot = container_of(c, sd_bus_slot, reply_callback);
2176 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2178 /* If the reply contained a file descriptor which we
2179 * didn't want we pass an error instead. */
2181 r = bus_message_new_synthetic_error(
2184 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2189 r = bus_seal_synthetic_message(bus, synthetic_reply);
2193 m = synthetic_reply;
2195 r = sd_bus_message_rewind(m, true);
2200 if (c->timeout != 0) {
2201 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2205 bus->current_slot = sd_bus_slot_ref(slot);
2206 bus->current_handler = c->callback;
2207 bus->current_userdata = slot->userdata;
2208 r = c->callback(bus, m, slot->userdata, &error_buffer);
2209 bus->current_userdata = NULL;
2210 bus->current_handler = NULL;
2211 bus->current_slot = NULL;
2213 if (slot->floating) {
2214 bus_slot_disconnect(slot);
2215 sd_bus_slot_unref(slot);
2218 sd_bus_slot_unref(slot);
2220 return bus_maybe_reply_error(m, r, &error_buffer);
2223 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2224 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2225 struct filter_callback *l;
2232 bus->filter_callbacks_modified = false;
2234 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2237 if (bus->filter_callbacks_modified)
2240 /* Don't run this more than once per iteration */
2241 if (l->last_iteration == bus->iteration_counter)
2244 l->last_iteration = bus->iteration_counter;
2246 r = sd_bus_message_rewind(m, true);
2250 slot = container_of(l, sd_bus_slot, filter_callback);
2252 bus->current_slot = sd_bus_slot_ref(slot);
2253 bus->current_handler = l->callback;
2254 bus->current_userdata = slot->userdata;
2255 r = l->callback(bus, m, slot->userdata, &error_buffer);
2256 bus->current_userdata = NULL;
2257 bus->current_handler = NULL;
2258 bus->current_slot = sd_bus_slot_unref(slot);
2260 r = bus_maybe_reply_error(m, r, &error_buffer);
2266 } while (bus->filter_callbacks_modified);
2271 static int process_match(sd_bus *bus, sd_bus_message *m) {
2278 bus->match_callbacks_modified = false;
2280 r = bus_match_run(bus, &bus->match_callbacks, m);
2284 } while (bus->match_callbacks_modified);
2289 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2290 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2296 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2299 if (bus->manual_peer_interface)
2302 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2305 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2308 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2311 if (streq_ptr(m->member, "Ping"))
2312 r = sd_bus_message_new_method_return(m, &reply);
2313 else if (streq_ptr(m->member, "GetMachineId")) {
2317 r = sd_id128_get_machine(&id);
2321 r = sd_bus_message_new_method_return(m, &reply);
2325 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2327 r = sd_bus_message_new_method_errorf(
2329 SD_BUS_ERROR_UNKNOWN_METHOD,
2330 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2336 r = sd_bus_send(bus, reply, NULL);
2343 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2347 /* If we got a message with a file descriptor which we didn't
2348 * want to accept, then let's drop it. How can this even
2349 * happen? For example, when the kernel queues a message into
2350 * an activatable names's queue which allows fds, and then is
2351 * delivered to us later even though we ourselves did not
2354 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2360 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2363 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2364 return 1; /* just eat it up */
2366 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2369 static int process_message(sd_bus *bus, sd_bus_message *m) {
2375 bus->current_message = m;
2376 bus->iteration_counter++;
2378 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2379 bus_message_type_to_string(m->header->type),
2380 strna(sd_bus_message_get_sender(m)),
2381 strna(sd_bus_message_get_destination(m)),
2382 strna(sd_bus_message_get_path(m)),
2383 strna(sd_bus_message_get_interface(m)),
2384 strna(sd_bus_message_get_member(m)),
2385 BUS_MESSAGE_COOKIE(m),
2387 strna(m->error.message));
2389 r = process_hello(bus, m);
2393 r = process_reply(bus, m);
2397 r = process_fd_check(bus, m);
2401 r = process_filter(bus, m);
2405 r = process_match(bus, m);
2409 r = process_builtin(bus, m);
2413 r = bus_process_object(bus, m);
2416 bus->current_message = NULL;
2420 static int dispatch_track(sd_bus *bus) {
2423 if (!bus->track_queue)
2426 bus_track_dispatch(bus->track_queue);
2430 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2431 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2435 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2437 r = process_timeout(bus);
2441 r = dispatch_wqueue(bus);
2445 r = dispatch_track(bus);
2449 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2455 r = process_message(bus, m);
2460 r = sd_bus_message_rewind(m, true);
2469 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2471 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2472 strna(sd_bus_message_get_sender(m)),
2473 strna(sd_bus_message_get_path(m)),
2474 strna(sd_bus_message_get_interface(m)),
2475 strna(sd_bus_message_get_member(m)));
2477 r = sd_bus_reply_method_errorf(
2479 SD_BUS_ERROR_UNKNOWN_OBJECT,
2480 "Unknown object '%s'.", m->path);
2494 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2495 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2496 struct reply_callback *c;
2500 assert(bus->state == BUS_CLOSING);
2502 c = hashmap_first(bus->reply_callbacks);
2504 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2507 /* First, fail all outstanding method calls */
2508 r = bus_message_new_synthetic_error(
2511 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2516 r = bus_seal_synthetic_message(bus, m);
2520 if (c->timeout != 0) {
2521 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2525 hashmap_remove(bus->reply_callbacks, &c->cookie);
2528 slot = container_of(c, sd_bus_slot, reply_callback);
2530 bus->iteration_counter++;
2532 bus->current_message = m;
2533 bus->current_slot = sd_bus_slot_ref(slot);
2534 bus->current_handler = c->callback;
2535 bus->current_userdata = slot->userdata;
2536 r = c->callback(bus, m, slot->userdata, &error_buffer);
2537 bus->current_userdata = NULL;
2538 bus->current_handler = NULL;
2539 bus->current_slot = NULL;
2540 bus->current_message = NULL;
2542 if (slot->floating) {
2543 bus_slot_disconnect(slot);
2544 sd_bus_slot_unref(slot);
2547 sd_bus_slot_unref(slot);
2549 return bus_maybe_reply_error(m, r, &error_buffer);
2552 /* Then, synthesize a Disconnected message */
2553 r = sd_bus_message_new_signal(
2556 "/org/freedesktop/DBus/Local",
2557 "org.freedesktop.DBus.Local",
2562 m->sender = "org.freedesktop.DBus.Local";
2564 r = bus_seal_synthetic_message(bus, m);
2570 bus->current_message = m;
2571 bus->iteration_counter++;
2573 r = process_filter(bus, m);
2577 r = process_match(bus, m);
2589 bus->current_message = NULL;
2594 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2595 BUS_DONT_DESTROY(bus);
2598 /* Returns 0 when we didn't do anything. This should cause the
2599 * caller to invoke sd_bus_wait() before returning the next
2600 * time. Returns > 0 when we did something, which possibly
2601 * means *ret is filled in with an unprocessed message. */
2603 assert_return(bus, -EINVAL);
2604 assert_return(!bus_pid_changed(bus), -ECHILD);
2606 /* We don't allow recursively invoking sd_bus_process(). */
2607 assert_return(!bus->current_message, -EBUSY);
2608 assert(!bus->current_slot);
2610 switch (bus->state) {
2619 r = bus_socket_process_opening(bus);
2620 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2621 bus_enter_closing(bus);
2629 case BUS_AUTHENTICATING:
2630 r = bus_socket_process_authenticating(bus);
2631 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2632 bus_enter_closing(bus);
2644 r = process_running(bus, hint_priority, priority, ret);
2645 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2646 bus_enter_closing(bus);
2656 return process_closing(bus, ret);
2659 assert_not_reached("Unknown state");
2662 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2663 return bus_process_internal(bus, false, 0, ret);
2666 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2667 return bus_process_internal(bus, true, priority, ret);
2670 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2671 struct pollfd p[2] = {};
2674 usec_t m = USEC_INFINITY;
2678 if (bus->state == BUS_CLOSING)
2681 if (!BUS_IS_OPEN(bus->state))
2684 e = sd_bus_get_events(bus);
2689 /* The caller really needs some more data, he doesn't
2690 * care about what's already read, or any timeouts
2695 /* The caller wants to process if there's something to
2696 * process, but doesn't care otherwise */
2698 r = sd_bus_get_timeout(bus, &until);
2703 nw = now(CLOCK_MONOTONIC);
2704 m = until > nw ? until - nw : 0;
2708 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2711 p[0].fd = bus->input_fd;
2712 if (bus->output_fd == bus->input_fd) {
2716 p[0].events = e & POLLIN;
2717 p[1].fd = bus->output_fd;
2718 p[1].events = e & POLLOUT;
2722 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2726 return r > 0 ? 1 : 0;
2729 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2731 assert_return(bus, -EINVAL);
2732 assert_return(!bus_pid_changed(bus), -ECHILD);
2734 if (bus->state == BUS_CLOSING)
2737 if (!BUS_IS_OPEN(bus->state))
2740 if (bus->rqueue_size > 0)
2743 return bus_poll(bus, false, timeout_usec);
2746 _public_ int sd_bus_flush(sd_bus *bus) {
2749 assert_return(bus, -EINVAL);
2750 assert_return(!bus_pid_changed(bus), -ECHILD);
2752 if (bus->state == BUS_CLOSING)
2755 if (!BUS_IS_OPEN(bus->state))
2758 r = bus_ensure_running(bus);
2762 if (bus->wqueue_size <= 0)
2766 r = dispatch_wqueue(bus);
2768 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2769 bus_enter_closing(bus);
2776 if (bus->wqueue_size <= 0)
2779 r = bus_poll(bus, false, (uint64_t) -1);
2785 _public_ int sd_bus_add_filter(
2788 sd_bus_message_handler_t callback,
2793 assert_return(bus, -EINVAL);
2794 assert_return(callback, -EINVAL);
2795 assert_return(!bus_pid_changed(bus), -ECHILD);
2797 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2801 s->filter_callback.callback = callback;
2803 bus->filter_callbacks_modified = true;
2804 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2812 _public_ int sd_bus_add_match(
2816 sd_bus_message_handler_t callback,
2819 struct bus_match_component *components = NULL;
2820 unsigned n_components = 0;
2821 sd_bus_slot *s = NULL;
2824 assert_return(bus, -EINVAL);
2825 assert_return(match, -EINVAL);
2826 assert_return(!bus_pid_changed(bus), -ECHILD);
2828 r = bus_match_parse(match, &components, &n_components);
2832 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2838 s->match_callback.callback = callback;
2839 s->match_callback.cookie = ++bus->match_cookie;
2841 if (bus->bus_client) {
2843 if (!bus->is_kernel) {
2844 /* When this is not a kernel transport, we
2845 * store the original match string, so that we
2846 * can use it to remove the match again */
2848 s->match_callback.match_string = strdup(match);
2849 if (!s->match_callback.match_string) {
2855 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2860 bus->match_callbacks_modified = true;
2861 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2870 bus_match_parse_free(components, n_components);
2871 sd_bus_slot_unref(s);
2876 int bus_remove_match_by_string(
2879 sd_bus_message_handler_t callback,
2882 struct bus_match_component *components = NULL;
2883 unsigned n_components = 0;
2884 struct match_callback *c;
2887 assert_return(bus, -EINVAL);
2888 assert_return(match, -EINVAL);
2889 assert_return(!bus_pid_changed(bus), -ECHILD);
2891 r = bus_match_parse(match, &components, &n_components);
2895 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2899 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2902 bus_match_parse_free(components, n_components);
2907 bool bus_pid_changed(sd_bus *bus) {
2910 /* We don't support people creating a bus connection and
2911 * keeping it around over a fork(). Let's complain. */
2913 return bus->original_pid != getpid();
2916 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2917 sd_bus *bus = userdata;
2922 r = sd_bus_process(bus, NULL);
2929 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2930 sd_bus *bus = userdata;
2935 r = sd_bus_process(bus, NULL);
2942 static int prepare_callback(sd_event_source *s, void *userdata) {
2943 sd_bus *bus = userdata;
2950 e = sd_bus_get_events(bus);
2954 if (bus->output_fd != bus->input_fd) {
2956 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2960 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2964 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2969 r = sd_bus_get_timeout(bus, &until);
2975 j = sd_event_source_set_time(bus->time_event_source, until);
2980 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2987 static int quit_callback(sd_event_source *event, void *userdata) {
2988 sd_bus *bus = userdata;
2998 static int attach_io_events(sd_bus *bus) {
3003 if (bus->input_fd < 0)
3009 if (!bus->input_io_event_source) {
3010 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3014 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3018 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3022 r = sd_event_source_set_name(bus->input_io_event_source, "bus-input");
3024 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3029 if (bus->output_fd != bus->input_fd) {
3030 assert(bus->output_fd >= 0);
3032 if (!bus->output_io_event_source) {
3033 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3037 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3041 r = sd_event_source_set_name(bus->input_io_event_source, "bus-output");
3043 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3052 static void detach_io_events(sd_bus *bus) {
3055 if (bus->input_io_event_source) {
3056 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3057 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3060 if (bus->output_io_event_source) {
3061 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3062 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3066 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3069 assert_return(bus, -EINVAL);
3070 assert_return(!bus->event, -EBUSY);
3072 assert(!bus->input_io_event_source);
3073 assert(!bus->output_io_event_source);
3074 assert(!bus->time_event_source);
3077 bus->event = sd_event_ref(event);
3079 r = sd_event_default(&bus->event);
3084 bus->event_priority = priority;
3086 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3090 r = sd_event_source_set_priority(bus->time_event_source, priority);
3094 r = sd_event_source_set_name(bus->time_event_source, "bus-time");
3098 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3102 r = sd_event_source_set_name(bus->quit_event_source, "bus-exit");
3106 r = attach_io_events(bus);
3113 sd_bus_detach_event(bus);
3117 _public_ int sd_bus_detach_event(sd_bus *bus) {
3118 assert_return(bus, -EINVAL);
3123 detach_io_events(bus);
3125 if (bus->time_event_source) {
3126 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3127 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3130 if (bus->quit_event_source) {
3131 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3132 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3135 bus->event = sd_event_unref(bus->event);
3139 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3140 assert_return(bus, NULL);
3145 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3146 assert_return(bus, NULL);
3148 return bus->current_message;
3151 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3152 assert_return(bus, NULL);
3154 return bus->current_slot;
3157 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3158 assert_return(bus, NULL);
3160 return bus->current_handler;
3163 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3164 assert_return(bus, NULL);
3166 return bus->current_userdata;
3169 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3174 assert(default_bus);
3177 return !!*default_bus;
3180 *ret = sd_bus_ref(*default_bus);
3188 b->default_bus_ptr = default_bus;
3196 _public_ int sd_bus_default_system(sd_bus **ret) {
3197 static thread_local sd_bus *default_system_bus = NULL;
3199 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3202 _public_ int sd_bus_default_user(sd_bus **ret) {
3203 static thread_local sd_bus *default_user_bus = NULL;
3205 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3208 _public_ int sd_bus_default(sd_bus **ret) {
3212 /* Let's try our best to reuse another cached connection. If
3213 * the starter bus type is set, connect via our normal
3214 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3215 * we can share the connection with the user/system default
3218 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3220 if (streq(e, "system"))
3221 return sd_bus_default_system(ret);
3222 else if (STR_IN_SET(e, "user", "session"))
3223 return sd_bus_default_user(ret);
3226 /* No type is specified, so we have not other option than to
3227 * use the starter address if it is set. */
3229 e = secure_getenv("DBUS_STARTER_ADDRESS");
3231 static thread_local sd_bus *default_starter_bus = NULL;
3233 return bus_default(sd_bus_open, &default_starter_bus, ret);
3236 /* Finally, if nothing is set use the cached connection for
3237 * the right scope */
3239 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3240 return sd_bus_default_user(ret);
3242 return sd_bus_default_system(ret);
3245 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3246 assert_return(b, -EINVAL);
3247 assert_return(tid, -EINVAL);
3248 assert_return(!bus_pid_changed(b), -ECHILD);
3256 return sd_event_get_tid(b->event, tid);
3261 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3262 _cleanup_free_ char *e = NULL;
3265 assert_return(object_path_is_valid(prefix), -EINVAL);
3266 assert_return(external_id, -EINVAL);
3267 assert_return(ret_path, -EINVAL);
3269 e = bus_label_escape(external_id);
3273 ret = strjoin(prefix, "/", e, NULL);
3281 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3285 assert_return(object_path_is_valid(path), -EINVAL);
3286 assert_return(object_path_is_valid(prefix), -EINVAL);
3287 assert_return(external_id, -EINVAL);
3289 e = object_path_startswith(path, prefix);
3291 *external_id = NULL;
3295 ret = bus_label_unescape(e);
3303 _public_ int sd_bus_get_owner_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3308 assert_return(bus, -EINVAL);
3309 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3310 assert_return(ret, -EINVAL);
3311 assert_return(!bus_pid_changed(bus), -ECHILD);
3316 if (!BUS_IS_OPEN(bus->state))
3319 if (!bus->ucred_valid && !isempty(bus->label))
3322 c = bus_creds_new();
3326 if (bus->ucred_valid) {
3327 pid = c->pid = bus->ucred.pid;
3328 c->uid = bus->ucred.uid;
3329 c->gid = bus->ucred.gid;
3331 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3334 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3335 c->label = strdup(bus->label);
3337 sd_bus_creds_unref(c);
3341 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3344 r = bus_creds_add_more(c, mask, pid, 0);
3346 sd_bus_creds_unref(c);
3354 _public_ int sd_bus_try_close(sd_bus *bus) {
3357 assert_return(bus, -EINVAL);
3358 assert_return(!bus_pid_changed(bus), -ECHILD);
3360 if (!bus->is_kernel)
3363 if (!BUS_IS_OPEN(bus->state))
3366 if (bus->rqueue_size > 0)
3369 if (bus->wqueue_size > 0)
3372 r = bus_kernel_try_close(bus);
3380 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3381 assert_return(bus, -EINVAL);
3382 assert_return(name, -EINVAL);
3383 assert_return(!bus_pid_changed(bus), -ECHILD);
3385 *name = bus->connection_name;
3389 int bus_get_root_path(sd_bus *bus) {
3392 if (bus->cgroup_root)
3395 r = cg_get_root_path(&bus->cgroup_root);
3397 bus->cgroup_root = strdup("/");
3398 if (!bus->cgroup_root)