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->description);
135 strv_free(b->exec_argv);
137 close_many(b->fds, b->n_fds);
142 ordered_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) {
278 assert_return(bus, -EINVAL);
279 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
280 assert_return(!bus_pid_changed(bus), -ECHILD);
282 new_flags = bus->attach_flags;
283 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
285 if (bus->attach_flags == new_flags)
288 bus->attach_flags = new_flags;
289 if (bus->state != BUS_UNSET && bus->is_kernel)
290 bus_kernel_realize_attach_flags(bus);
295 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
298 assert_return(bus, -EINVAL);
299 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
300 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
301 assert_return(!bus_pid_changed(bus), -ECHILD);
304 bus->creds_mask |= mask;
306 bus->creds_mask &= ~mask;
308 /* The well knowns we need unconditionally, so that matches can work */
309 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
311 /* Make sure we don't lose the timestamp flag */
312 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
313 if (bus->attach_flags == new_flags)
316 bus->attach_flags = new_flags;
317 if (bus->state != BUS_UNSET && bus->is_kernel)
318 bus_kernel_realize_attach_flags(bus);
323 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
324 assert_return(bus, -EINVAL);
325 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
326 assert_return(bus->state == BUS_UNSET, -EPERM);
327 assert_return(!bus_pid_changed(bus), -ECHILD);
329 bus->is_server = !!b;
330 bus->server_id = server_id;
334 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
335 assert_return(bus, -EINVAL);
336 assert_return(bus->state == BUS_UNSET, -EPERM);
337 assert_return(!bus_pid_changed(bus), -ECHILD);
339 bus->anonymous_auth = !!b;
343 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
344 assert_return(bus, -EINVAL);
345 assert_return(bus->state == BUS_UNSET, -EPERM);
346 assert_return(!bus_pid_changed(bus), -ECHILD);
352 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
353 assert_return(bus, -EINVAL);
354 assert_return(bus->state == BUS_UNSET, -EPERM);
355 assert_return(!bus_pid_changed(bus), -ECHILD);
357 return free_and_strdup(&bus->description, description);
360 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
365 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
368 r = sd_bus_message_get_errno(reply);
372 r = sd_bus_message_read(reply, "s", &s);
376 if (!service_name_is_valid(s) || s[0] != ':')
379 bus->unique_name = strdup(s);
380 if (!bus->unique_name)
383 if (bus->state == BUS_HELLO)
384 bus->state = BUS_RUNNING;
389 static int bus_send_hello(sd_bus *bus) {
390 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
395 if (!bus->bus_client || bus->is_kernel)
398 r = sd_bus_message_new_method_call(
401 "org.freedesktop.DBus",
402 "/org/freedesktop/DBus",
403 "org.freedesktop.DBus",
408 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
411 int bus_start_running(sd_bus *bus) {
414 if (bus->bus_client && !bus->is_kernel) {
415 bus->state = BUS_HELLO;
419 bus->state = BUS_RUNNING;
423 static int parse_address_key(const char **p, const char *key, char **value) {
424 size_t l, n = 0, allocated = 0;
434 if (strncmp(*p, key, l) != 0)
447 while (*a != ';' && *a != ',' && *a != 0) {
465 c = (char) ((x << 4) | y);
472 if (!GREEDY_REALLOC(r, allocated, n + 2))
496 static void skip_address_key(const char **p) {
500 *p += strcspn(*p, ",");
506 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
507 _cleanup_free_ char *path = NULL, *abstract = NULL;
516 while (**p != 0 && **p != ';') {
517 r = parse_address_key(p, "guid", guid);
523 r = parse_address_key(p, "path", &path);
529 r = parse_address_key(p, "abstract", &abstract);
538 if (!path && !abstract)
541 if (path && abstract)
546 if (l > sizeof(b->sockaddr.un.sun_path))
549 b->sockaddr.un.sun_family = AF_UNIX;
550 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
551 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
552 } else if (abstract) {
553 l = strlen(abstract);
554 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
557 b->sockaddr.un.sun_family = AF_UNIX;
558 b->sockaddr.un.sun_path[0] = 0;
559 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
560 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
566 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
567 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
569 struct addrinfo *result, hints = {
570 .ai_socktype = SOCK_STREAM,
571 .ai_flags = AI_ADDRCONFIG,
579 while (**p != 0 && **p != ';') {
580 r = parse_address_key(p, "guid", guid);
586 r = parse_address_key(p, "host", &host);
592 r = parse_address_key(p, "port", &port);
598 r = parse_address_key(p, "family", &family);
611 if (streq(family, "ipv4"))
612 hints.ai_family = AF_INET;
613 else if (streq(family, "ipv6"))
614 hints.ai_family = AF_INET6;
619 r = getaddrinfo(host, port, &hints, &result);
623 return -EADDRNOTAVAIL;
625 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
626 b->sockaddr_size = result->ai_addrlen;
628 freeaddrinfo(result);
633 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
635 unsigned n_argv = 0, j;
637 size_t allocated = 0;
645 while (**p != 0 && **p != ';') {
646 r = parse_address_key(p, "guid", guid);
652 r = parse_address_key(p, "path", &path);
658 if (startswith(*p, "argv")) {
662 ul = strtoul(*p + 4, (char**) p, 10);
663 if (errno > 0 || **p != '=' || ul > 256) {
671 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
679 r = parse_address_key(p, NULL, argv + ul);
694 /* Make sure there are no holes in the array, with the
695 * exception of argv[0] */
696 for (j = 1; j < n_argv; j++)
702 if (argv && argv[0] == NULL) {
703 argv[0] = strdup(path);
715 for (j = 0; j < n_argv; j++)
723 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
724 _cleanup_free_ char *path = NULL;
732 while (**p != 0 && **p != ';') {
733 r = parse_address_key(p, "guid", guid);
739 r = parse_address_key(p, "path", &path);
758 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
759 _cleanup_free_ char *machine = NULL;
767 while (**p != 0 && **p != ';') {
768 r = parse_address_key(p, "guid", guid);
774 r = parse_address_key(p, "machine", &machine);
786 if (!machine_name_is_valid(machine))
790 b->machine = machine;
793 b->sockaddr.un.sun_family = AF_UNIX;
794 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
795 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
800 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
801 _cleanup_free_ char *machine = NULL;
809 while (**p != 0 && **p != ';') {
810 r = parse_address_key(p, "guid", guid);
816 r = parse_address_key(p, "machine", &machine);
828 if (!machine_name_is_valid(machine))
832 b->machine = machine;
836 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
843 static void bus_reset_parsed_address(sd_bus *b) {
847 b->sockaddr_size = 0;
848 strv_free(b->exec_argv);
852 b->server_id = SD_ID128_NULL;
859 static int bus_parse_next_address(sd_bus *b) {
860 _cleanup_free_ char *guid = NULL;
868 if (b->address[b->address_index] == 0)
871 bus_reset_parsed_address(b);
873 a = b->address + b->address_index;
882 if (startswith(a, "unix:")) {
885 r = parse_unix_address(b, &a, &guid);
890 } else if (startswith(a, "tcp:")) {
893 r = parse_tcp_address(b, &a, &guid);
899 } else if (startswith(a, "unixexec:")) {
902 r = parse_exec_address(b, &a, &guid);
908 } else if (startswith(a, "kernel:")) {
911 r = parse_kernel_address(b, &a, &guid);
916 } else if (startswith(a, "x-container-unix:")) {
919 r = parse_container_unix_address(b, &a, &guid);
924 } else if (startswith(a, "x-container-kernel:")) {
927 r = parse_container_kernel_address(b, &a, &guid);
940 r = sd_id128_from_string(guid, &b->server_id);
945 b->address_index = a - b->address;
949 static int bus_start_address(sd_bus *b) {
955 bool skipped = false;
960 r = bus_socket_exec(b);
961 else if (b->machine && b->kernel)
962 r = bus_container_connect_kernel(b);
963 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
964 r = bus_container_connect_socket(b);
966 r = bus_kernel_connect(b);
967 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
968 r = bus_socket_connect(b);
974 r = attach_io_events(b);
979 b->last_connect_error = -r;
982 r = bus_parse_next_address(b);
986 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
990 int bus_next_address(sd_bus *b) {
993 bus_reset_parsed_address(b);
994 return bus_start_address(b);
997 static int bus_start_fd(sd_bus *b) {
1002 assert(b->input_fd >= 0);
1003 assert(b->output_fd >= 0);
1005 r = fd_nonblock(b->input_fd, true);
1009 r = fd_cloexec(b->input_fd, true);
1013 if (b->input_fd != b->output_fd) {
1014 r = fd_nonblock(b->output_fd, true);
1018 r = fd_cloexec(b->output_fd, true);
1023 if (fstat(b->input_fd, &st) < 0)
1026 if (S_ISCHR(b->input_fd))
1027 return bus_kernel_take_fd(b);
1029 return bus_socket_take_fd(b);
1032 _public_ int sd_bus_start(sd_bus *bus) {
1035 assert_return(bus, -EINVAL);
1036 assert_return(bus->state == BUS_UNSET, -EPERM);
1037 assert_return(!bus_pid_changed(bus), -ECHILD);
1039 bus->state = BUS_OPENING;
1041 if (bus->is_server && bus->bus_client)
1044 if (bus->input_fd >= 0)
1045 r = bus_start_fd(bus);
1046 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1047 r = bus_start_address(bus);
1056 return bus_send_hello(bus);
1059 _public_ int sd_bus_open(sd_bus **ret) {
1064 assert_return(ret, -EINVAL);
1066 /* Let's connect to the starter bus if it is set, and
1067 * otherwise to the bus that is appropropriate for the scope
1068 * we are running in */
1070 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1072 if (streq(e, "system"))
1073 return sd_bus_open_system(ret);
1074 else if (STR_IN_SET(e, "session", "user"))
1075 return sd_bus_open_user(ret);
1078 e = secure_getenv("DBUS_STARTER_ADDRESS");
1080 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1081 return sd_bus_open_user(ret);
1083 return sd_bus_open_system(ret);
1090 r = sd_bus_set_address(b, e);
1094 b->bus_client = true;
1096 /* We don't know whether the bus is trusted or not, so better
1097 * be safe, and authenticate everything */
1099 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1100 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1102 r = sd_bus_start(b);
1114 int bus_set_address_system(sd_bus *b) {
1118 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1120 return sd_bus_set_address(b, e);
1122 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1125 _public_ int sd_bus_open_system(sd_bus **ret) {
1129 assert_return(ret, -EINVAL);
1135 r = bus_set_address_system(b);
1139 b->bus_client = true;
1140 b->is_system = true;
1142 /* Let's do per-method access control on the system bus. We
1143 * need the caller's UID and capability set for that. */
1145 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1146 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1148 r = sd_bus_start(b);
1160 int bus_set_address_user(sd_bus *b) {
1165 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1167 return sd_bus_set_address(b, e);
1169 e = secure_getenv("XDG_RUNTIME_DIR");
1171 _cleanup_free_ char *ee = NULL;
1173 ee = bus_address_escape(e);
1178 (void) asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1180 (void) asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1184 (void) asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1186 return -ECONNREFUSED;
1196 _public_ int sd_bus_open_user(sd_bus **ret) {
1200 assert_return(ret, -EINVAL);
1206 r = bus_set_address_user(b);
1210 b->bus_client = true;
1213 /* We don't do any per-method access control on the user
1217 r = sd_bus_start(b);
1229 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1230 _cleanup_free_ char *e = NULL;
1231 char *m = NULL, *c = NULL;
1236 /* Let's see if we shall enter some container */
1237 m = strchr(host, ':');
1241 /* Let's make sure this is not a port of some kind,
1242 * and is a valid machine name. */
1243 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1246 /* Cut out the host part */
1247 t = strndupa(host, m - host - 1);
1248 e = bus_address_escape(t);
1252 c = strappenda(",argv4=--machine=", m);
1257 e = bus_address_escape(host);
1262 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1269 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1273 assert_return(host, -EINVAL);
1274 assert_return(ret, -EINVAL);
1276 r = sd_bus_new(&bus);
1280 r = bus_set_address_system_remote(bus, host);
1284 bus->bus_client = true;
1285 bus->trusted = false;
1287 r = sd_bus_start(bus);
1299 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1300 _cleanup_free_ char *e = NULL;
1305 e = bus_address_escape(machine);
1310 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1312 b->address = strjoin("x-container-unix:machine=", e, NULL);
1320 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1324 assert_return(machine, -EINVAL);
1325 assert_return(ret, -EINVAL);
1326 assert_return(machine_name_is_valid(machine), -EINVAL);
1328 r = sd_bus_new(&bus);
1332 r = bus_set_address_system_container(bus, machine);
1336 bus->bus_client = true;
1337 bus->trusted = false;
1339 r = sd_bus_start(bus);
1351 _public_ void sd_bus_close(sd_bus *bus) {
1355 if (bus->state == BUS_CLOSED)
1357 if (bus_pid_changed(bus))
1360 bus->state = BUS_CLOSED;
1362 sd_bus_detach_event(bus);
1364 /* Drop all queued messages so that they drop references to
1365 * the bus object and the bus may be freed */
1366 bus_reset_queues(bus);
1368 if (!bus->is_kernel)
1371 /* We'll leave the fd open in case this is a kernel bus, since
1372 * there might still be memblocks around that reference this
1373 * bus, and they might need to invoke the KDBUS_CMD_FREE
1374 * ioctl on the fd when they are freed. */
1377 static void bus_enter_closing(sd_bus *bus) {
1380 if (bus->state != BUS_OPENING &&
1381 bus->state != BUS_AUTHENTICATING &&
1382 bus->state != BUS_HELLO &&
1383 bus->state != BUS_RUNNING)
1386 bus->state = BUS_CLOSING;
1389 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1390 assert_return(bus, NULL);
1392 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1397 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1403 i = REFCNT_DEC(bus->n_ref);
1411 _public_ int sd_bus_is_open(sd_bus *bus) {
1413 assert_return(bus, -EINVAL);
1414 assert_return(!bus_pid_changed(bus), -ECHILD);
1416 return BUS_IS_OPEN(bus->state);
1419 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1422 assert_return(bus, -EINVAL);
1423 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1424 assert_return(!bus_pid_changed(bus), -ECHILD);
1426 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1429 if (type == SD_BUS_TYPE_UNIX_FD) {
1430 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1433 r = bus_ensure_running(bus);
1437 return bus->can_fds;
1440 return bus_type_is_valid(type);
1443 _public_ int sd_bus_get_owner_id(sd_bus *bus, sd_id128_t *id) {
1446 assert_return(bus, -EINVAL);
1447 assert_return(id, -EINVAL);
1448 assert_return(!bus_pid_changed(bus), -ECHILD);
1450 r = bus_ensure_running(bus);
1454 *id = bus->server_id;
1458 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1463 /* If we copy the same message to multiple
1464 * destinations, avoid using the same cookie
1466 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1471 timeout = BUS_DEFAULT_TIMEOUT;
1473 return bus_message_seal(m, ++b->cookie, timeout);
1476 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1479 /* Do packet version and endianness already match? */
1480 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1481 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1484 /* No? Then remarshal! */
1485 return bus_message_remarshal(b, m);
1488 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1492 /* The bus specification says the serial number cannot be 0,
1493 * hence let's fill something in for synthetic messages. Since
1494 * synthetic messages might have a fake sender and we don't
1495 * want to interfere with the real sender's serial numbers we
1496 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1497 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1498 * even though kdbus can do 64bit. */
1500 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1503 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1510 r = bus_kernel_write_message(bus, m, hint_sync_call);
1512 r = bus_socket_write_message(bus, m, idx);
1517 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1518 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1519 bus_message_type_to_string(m->header->type),
1520 strna(sd_bus_message_get_sender(m)),
1521 strna(sd_bus_message_get_destination(m)),
1522 strna(sd_bus_message_get_path(m)),
1523 strna(sd_bus_message_get_interface(m)),
1524 strna(sd_bus_message_get_member(m)),
1525 BUS_MESSAGE_COOKIE(m),
1527 strna(m->error.message));
1532 static int dispatch_wqueue(sd_bus *bus) {
1536 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1538 while (bus->wqueue_size > 0) {
1540 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1544 /* Didn't do anything this time */
1546 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1547 /* Fully written. Let's drop the entry from
1550 * This isn't particularly optimized, but
1551 * well, this is supposed to be our worst-case
1552 * buffer only, and the socket buffer is
1553 * supposed to be our primary buffer, and if
1554 * it got full, then all bets are off
1557 bus->wqueue_size --;
1558 sd_bus_message_unref(bus->wqueue[0]);
1559 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1569 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1573 return bus_kernel_read_message(bus, hint_priority, priority);
1575 return bus_socket_read_message(bus);
1578 int bus_rqueue_make_room(sd_bus *bus) {
1581 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1584 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1590 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1595 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1597 /* Note that the priority logic is only available on kdbus,
1598 * where the rqueue is unused. We check the rqueue here
1599 * anyway, because it's simple... */
1602 if (bus->rqueue_size > 0) {
1603 /* Dispatch a queued message */
1605 *m = bus->rqueue[0];
1606 bus->rqueue_size --;
1607 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1611 /* Try to read a new message */
1612 r = bus_read_message(bus, hint_priority, priority);
1622 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1623 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1626 assert_return(bus, -EINVAL);
1627 assert_return(m, -EINVAL);
1628 assert_return(!bus_pid_changed(bus), -ECHILD);
1629 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1631 if (!BUS_IS_OPEN(bus->state))
1635 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1642 /* If the cookie number isn't kept, then we know that no reply
1644 if (!cookie && !m->sealed)
1645 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1647 r = bus_seal_message(bus, m, 0);
1651 /* Remarshall if we have to. This will possibly unref the
1652 * message and place a replacement in m */
1653 r = bus_remarshal_message(bus, &m);
1657 /* If this is a reply and no reply was requested, then let's
1658 * suppress this, if we can */
1659 if (m->dont_send && !cookie)
1662 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1665 r = bus_write_message(bus, m, hint_sync_call, &idx);
1667 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1668 bus_enter_closing(bus);
1673 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1674 /* Wasn't fully written. So let's remember how
1675 * much was written. Note that the first entry
1676 * of the wqueue array is always allocated so
1677 * that we always can remember how much was
1679 bus->wqueue[0] = sd_bus_message_ref(m);
1680 bus->wqueue_size = 1;
1684 /* Just append it to the queue. */
1686 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1689 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1692 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1696 *cookie = BUS_MESSAGE_COOKIE(m);
1701 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1702 return bus_send_internal(bus, m, cookie, false);
1705 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1708 assert_return(bus, -EINVAL);
1709 assert_return(m, -EINVAL);
1710 assert_return(!bus_pid_changed(bus), -ECHILD);
1712 if (!BUS_IS_OPEN(bus->state))
1715 if (!streq_ptr(m->destination, destination)) {
1720 r = sd_bus_message_set_destination(m, destination);
1725 return sd_bus_send(bus, m, cookie);
1728 static usec_t calc_elapse(uint64_t usec) {
1729 if (usec == (uint64_t) -1)
1732 return now(CLOCK_MONOTONIC) + usec;
1735 static int timeout_compare(const void *a, const void *b) {
1736 const struct reply_callback *x = a, *y = b;
1738 if (x->timeout != 0 && y->timeout == 0)
1741 if (x->timeout == 0 && y->timeout != 0)
1744 if (x->timeout < y->timeout)
1747 if (x->timeout > y->timeout)
1753 _public_ int sd_bus_call_async(
1757 sd_bus_message_handler_t callback,
1761 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1762 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1765 assert_return(bus, -EINVAL);
1766 assert_return(m, -EINVAL);
1767 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1768 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1769 assert_return(callback, -EINVAL);
1770 assert_return(!bus_pid_changed(bus), -ECHILD);
1771 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1773 if (!BUS_IS_OPEN(bus->state))
1776 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1780 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1784 r = bus_seal_message(bus, m, usec);
1788 r = bus_remarshal_message(bus, &m);
1792 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1796 s->reply_callback.callback = callback;
1798 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1799 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1801 s->reply_callback.cookie = 0;
1805 s->reply_callback.timeout = calc_elapse(m->timeout);
1806 if (s->reply_callback.timeout != 0) {
1807 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1809 s->reply_callback.timeout = 0;
1814 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1825 int bus_ensure_running(sd_bus *bus) {
1830 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1832 if (bus->state == BUS_RUNNING)
1836 r = sd_bus_process(bus, NULL);
1839 if (bus->state == BUS_RUNNING)
1844 r = sd_bus_wait(bus, (uint64_t) -1);
1850 _public_ int sd_bus_call(
1854 sd_bus_error *error,
1855 sd_bus_message **reply) {
1857 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1863 assert_return(bus, -EINVAL);
1864 assert_return(m, -EINVAL);
1865 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1866 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1867 assert_return(!bus_error_is_dirty(error), -EINVAL);
1868 assert_return(!bus_pid_changed(bus), -ECHILD);
1869 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1871 if (!BUS_IS_OPEN(bus->state))
1874 r = bus_ensure_running(bus);
1878 i = bus->rqueue_size;
1880 r = bus_seal_message(bus, m, usec);
1884 r = bus_remarshal_message(bus, &m);
1888 r = bus_send_internal(bus, m, &cookie, true);
1892 timeout = calc_elapse(m->timeout);
1897 while (i < bus->rqueue_size) {
1898 sd_bus_message *incoming = NULL;
1900 incoming = bus->rqueue[i];
1902 if (incoming->reply_cookie == cookie) {
1903 /* Found a match! */
1905 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1908 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1910 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1914 sd_bus_message_unref(incoming);
1919 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1921 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1922 r = sd_bus_error_copy(error, &incoming->error);
1926 sd_bus_message_unref(incoming);
1929 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1932 streq(bus->unique_name, incoming->sender)) {
1934 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1937 /* Our own message? Somebody is trying
1938 * to send its own client a message,
1939 * let's not dead-lock, let's fail
1942 sd_bus_message_unref(incoming);
1946 /* Try to read more, right-away */
1950 r = bus_read_message(bus, false, 0);
1952 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1953 bus_enter_closing(bus);
1965 n = now(CLOCK_MONOTONIC);
1971 left = (uint64_t) -1;
1973 r = bus_poll(bus, true, left);
1979 r = dispatch_wqueue(bus);
1981 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1982 bus_enter_closing(bus);
1991 _public_ int sd_bus_get_fd(sd_bus *bus) {
1993 assert_return(bus, -EINVAL);
1994 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1995 assert_return(!bus_pid_changed(bus), -ECHILD);
1997 return bus->input_fd;
2000 _public_ int sd_bus_get_events(sd_bus *bus) {
2003 assert_return(bus, -EINVAL);
2004 assert_return(!bus_pid_changed(bus), -ECHILD);
2006 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2009 if (bus->state == BUS_OPENING)
2011 else if (bus->state == BUS_AUTHENTICATING) {
2013 if (bus_socket_auth_needs_write(bus))
2018 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2019 if (bus->rqueue_size <= 0)
2021 if (bus->wqueue_size > 0)
2028 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2029 struct reply_callback *c;
2031 assert_return(bus, -EINVAL);
2032 assert_return(timeout_usec, -EINVAL);
2033 assert_return(!bus_pid_changed(bus), -ECHILD);
2035 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2038 if (bus->track_queue) {
2043 if (bus->state == BUS_CLOSING) {
2048 if (bus->state == BUS_AUTHENTICATING) {
2049 *timeout_usec = bus->auth_timeout;
2053 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2054 *timeout_usec = (uint64_t) -1;
2058 if (bus->rqueue_size > 0) {
2063 c = prioq_peek(bus->reply_callbacks_prioq);
2065 *timeout_usec = (uint64_t) -1;
2069 if (c->timeout == 0) {
2070 *timeout_usec = (uint64_t) -1;
2074 *timeout_usec = c->timeout;
2078 static int process_timeout(sd_bus *bus) {
2079 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2080 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2081 struct reply_callback *c;
2088 c = prioq_peek(bus->reply_callbacks_prioq);
2092 n = now(CLOCK_MONOTONIC);
2096 r = bus_message_new_synthetic_error(
2099 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2104 m->sender = "org.freedesktop.DBus";
2106 r = bus_seal_synthetic_message(bus, m);
2110 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2113 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2116 slot = container_of(c, sd_bus_slot, reply_callback);
2118 bus->iteration_counter ++;
2120 bus->current_message = m;
2121 bus->current_slot = sd_bus_slot_ref(slot);
2122 bus->current_handler = c->callback;
2123 bus->current_userdata = slot->userdata;
2124 r = c->callback(bus, m, slot->userdata, &error_buffer);
2125 bus->current_userdata = NULL;
2126 bus->current_handler = NULL;
2127 bus->current_slot = NULL;
2128 bus->current_message = NULL;
2130 if (slot->floating) {
2131 bus_slot_disconnect(slot);
2132 sd_bus_slot_unref(slot);
2135 sd_bus_slot_unref(slot);
2137 return bus_maybe_reply_error(m, r, &error_buffer);
2140 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2144 if (bus->state != BUS_HELLO)
2147 /* Let's make sure the first message on the bus is the HELLO
2148 * reply. But note that we don't actually parse the message
2149 * here (we leave that to the usual handling), we just verify
2150 * we don't let any earlier msg through. */
2152 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2153 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2156 if (m->reply_cookie != 1)
2162 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2163 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2164 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2165 struct reply_callback *c;
2172 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2173 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2176 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2179 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2182 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2188 slot = container_of(c, sd_bus_slot, reply_callback);
2190 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2192 /* If the reply contained a file descriptor which we
2193 * didn't want we pass an error instead. */
2195 r = bus_message_new_synthetic_error(
2198 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2203 r = bus_seal_synthetic_message(bus, synthetic_reply);
2207 m = synthetic_reply;
2209 r = sd_bus_message_rewind(m, true);
2214 if (c->timeout != 0) {
2215 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2219 bus->current_slot = sd_bus_slot_ref(slot);
2220 bus->current_handler = c->callback;
2221 bus->current_userdata = slot->userdata;
2222 r = c->callback(bus, m, slot->userdata, &error_buffer);
2223 bus->current_userdata = NULL;
2224 bus->current_handler = NULL;
2225 bus->current_slot = NULL;
2227 if (slot->floating) {
2228 bus_slot_disconnect(slot);
2229 sd_bus_slot_unref(slot);
2232 sd_bus_slot_unref(slot);
2234 return bus_maybe_reply_error(m, r, &error_buffer);
2237 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2238 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2239 struct filter_callback *l;
2246 bus->filter_callbacks_modified = false;
2248 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2251 if (bus->filter_callbacks_modified)
2254 /* Don't run this more than once per iteration */
2255 if (l->last_iteration == bus->iteration_counter)
2258 l->last_iteration = bus->iteration_counter;
2260 r = sd_bus_message_rewind(m, true);
2264 slot = container_of(l, sd_bus_slot, filter_callback);
2266 bus->current_slot = sd_bus_slot_ref(slot);
2267 bus->current_handler = l->callback;
2268 bus->current_userdata = slot->userdata;
2269 r = l->callback(bus, m, slot->userdata, &error_buffer);
2270 bus->current_userdata = NULL;
2271 bus->current_handler = NULL;
2272 bus->current_slot = sd_bus_slot_unref(slot);
2274 r = bus_maybe_reply_error(m, r, &error_buffer);
2280 } while (bus->filter_callbacks_modified);
2285 static int process_match(sd_bus *bus, sd_bus_message *m) {
2292 bus->match_callbacks_modified = false;
2294 r = bus_match_run(bus, &bus->match_callbacks, m);
2298 } while (bus->match_callbacks_modified);
2303 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2304 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2310 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2313 if (bus->manual_peer_interface)
2316 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2319 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2322 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2325 if (streq_ptr(m->member, "Ping"))
2326 r = sd_bus_message_new_method_return(m, &reply);
2327 else if (streq_ptr(m->member, "GetMachineId")) {
2331 r = sd_id128_get_machine(&id);
2335 r = sd_bus_message_new_method_return(m, &reply);
2339 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2341 r = sd_bus_message_new_method_errorf(
2343 SD_BUS_ERROR_UNKNOWN_METHOD,
2344 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2350 r = sd_bus_send(bus, reply, NULL);
2357 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2361 /* If we got a message with a file descriptor which we didn't
2362 * want to accept, then let's drop it. How can this even
2363 * happen? For example, when the kernel queues a message into
2364 * an activatable names's queue which allows fds, and then is
2365 * delivered to us later even though we ourselves did not
2368 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2374 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2377 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2378 return 1; /* just eat it up */
2380 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2383 static int process_message(sd_bus *bus, sd_bus_message *m) {
2389 bus->current_message = m;
2390 bus->iteration_counter++;
2392 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2393 bus_message_type_to_string(m->header->type),
2394 strna(sd_bus_message_get_sender(m)),
2395 strna(sd_bus_message_get_destination(m)),
2396 strna(sd_bus_message_get_path(m)),
2397 strna(sd_bus_message_get_interface(m)),
2398 strna(sd_bus_message_get_member(m)),
2399 BUS_MESSAGE_COOKIE(m),
2401 strna(m->error.message));
2403 r = process_hello(bus, m);
2407 r = process_reply(bus, m);
2411 r = process_fd_check(bus, m);
2415 r = process_filter(bus, m);
2419 r = process_match(bus, m);
2423 r = process_builtin(bus, m);
2427 r = bus_process_object(bus, m);
2430 bus->current_message = NULL;
2434 static int dispatch_track(sd_bus *bus) {
2437 if (!bus->track_queue)
2440 bus_track_dispatch(bus->track_queue);
2444 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2445 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2449 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2451 r = process_timeout(bus);
2455 r = dispatch_wqueue(bus);
2459 r = dispatch_track(bus);
2463 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2469 r = process_message(bus, m);
2474 r = sd_bus_message_rewind(m, true);
2483 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2485 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2486 strna(sd_bus_message_get_sender(m)),
2487 strna(sd_bus_message_get_path(m)),
2488 strna(sd_bus_message_get_interface(m)),
2489 strna(sd_bus_message_get_member(m)));
2491 r = sd_bus_reply_method_errorf(
2493 SD_BUS_ERROR_UNKNOWN_OBJECT,
2494 "Unknown object '%s'.", m->path);
2508 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2509 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2510 struct reply_callback *c;
2514 assert(bus->state == BUS_CLOSING);
2516 c = ordered_hashmap_first(bus->reply_callbacks);
2518 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2521 /* First, fail all outstanding method calls */
2522 r = bus_message_new_synthetic_error(
2525 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2530 r = bus_seal_synthetic_message(bus, m);
2534 if (c->timeout != 0) {
2535 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2539 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2542 slot = container_of(c, sd_bus_slot, reply_callback);
2544 bus->iteration_counter++;
2546 bus->current_message = m;
2547 bus->current_slot = sd_bus_slot_ref(slot);
2548 bus->current_handler = c->callback;
2549 bus->current_userdata = slot->userdata;
2550 r = c->callback(bus, m, slot->userdata, &error_buffer);
2551 bus->current_userdata = NULL;
2552 bus->current_handler = NULL;
2553 bus->current_slot = NULL;
2554 bus->current_message = NULL;
2556 if (slot->floating) {
2557 bus_slot_disconnect(slot);
2558 sd_bus_slot_unref(slot);
2561 sd_bus_slot_unref(slot);
2563 return bus_maybe_reply_error(m, r, &error_buffer);
2566 /* Then, synthesize a Disconnected message */
2567 r = sd_bus_message_new_signal(
2570 "/org/freedesktop/DBus/Local",
2571 "org.freedesktop.DBus.Local",
2576 m->sender = "org.freedesktop.DBus.Local";
2578 r = bus_seal_synthetic_message(bus, m);
2584 bus->current_message = m;
2585 bus->iteration_counter++;
2587 r = process_filter(bus, m);
2591 r = process_match(bus, m);
2603 bus->current_message = NULL;
2608 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2609 BUS_DONT_DESTROY(bus);
2612 /* Returns 0 when we didn't do anything. This should cause the
2613 * caller to invoke sd_bus_wait() before returning the next
2614 * time. Returns > 0 when we did something, which possibly
2615 * means *ret is filled in with an unprocessed message. */
2617 assert_return(bus, -EINVAL);
2618 assert_return(!bus_pid_changed(bus), -ECHILD);
2620 /* We don't allow recursively invoking sd_bus_process(). */
2621 assert_return(!bus->current_message, -EBUSY);
2622 assert(!bus->current_slot);
2624 switch (bus->state) {
2633 r = bus_socket_process_opening(bus);
2634 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2635 bus_enter_closing(bus);
2643 case BUS_AUTHENTICATING:
2644 r = bus_socket_process_authenticating(bus);
2645 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2646 bus_enter_closing(bus);
2658 r = process_running(bus, hint_priority, priority, ret);
2659 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2660 bus_enter_closing(bus);
2670 return process_closing(bus, ret);
2673 assert_not_reached("Unknown state");
2676 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2677 return bus_process_internal(bus, false, 0, ret);
2680 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2681 return bus_process_internal(bus, true, priority, ret);
2684 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2685 struct pollfd p[2] = {};
2688 usec_t m = USEC_INFINITY;
2692 if (bus->state == BUS_CLOSING)
2695 if (!BUS_IS_OPEN(bus->state))
2698 e = sd_bus_get_events(bus);
2703 /* The caller really needs some more data, he doesn't
2704 * care about what's already read, or any timeouts
2709 /* The caller wants to process if there's something to
2710 * process, but doesn't care otherwise */
2712 r = sd_bus_get_timeout(bus, &until);
2717 nw = now(CLOCK_MONOTONIC);
2718 m = until > nw ? until - nw : 0;
2722 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2725 p[0].fd = bus->input_fd;
2726 if (bus->output_fd == bus->input_fd) {
2730 p[0].events = e & POLLIN;
2731 p[1].fd = bus->output_fd;
2732 p[1].events = e & POLLOUT;
2736 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2740 return r > 0 ? 1 : 0;
2743 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2745 assert_return(bus, -EINVAL);
2746 assert_return(!bus_pid_changed(bus), -ECHILD);
2748 if (bus->state == BUS_CLOSING)
2751 if (!BUS_IS_OPEN(bus->state))
2754 if (bus->rqueue_size > 0)
2757 return bus_poll(bus, false, timeout_usec);
2760 _public_ int sd_bus_flush(sd_bus *bus) {
2763 assert_return(bus, -EINVAL);
2764 assert_return(!bus_pid_changed(bus), -ECHILD);
2766 if (bus->state == BUS_CLOSING)
2769 if (!BUS_IS_OPEN(bus->state))
2772 r = bus_ensure_running(bus);
2776 if (bus->wqueue_size <= 0)
2780 r = dispatch_wqueue(bus);
2782 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2783 bus_enter_closing(bus);
2790 if (bus->wqueue_size <= 0)
2793 r = bus_poll(bus, false, (uint64_t) -1);
2799 _public_ int sd_bus_add_filter(
2802 sd_bus_message_handler_t callback,
2807 assert_return(bus, -EINVAL);
2808 assert_return(callback, -EINVAL);
2809 assert_return(!bus_pid_changed(bus), -ECHILD);
2811 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2815 s->filter_callback.callback = callback;
2817 bus->filter_callbacks_modified = true;
2818 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2826 _public_ int sd_bus_add_match(
2830 sd_bus_message_handler_t callback,
2833 struct bus_match_component *components = NULL;
2834 unsigned n_components = 0;
2835 sd_bus_slot *s = NULL;
2838 assert_return(bus, -EINVAL);
2839 assert_return(match, -EINVAL);
2840 assert_return(!bus_pid_changed(bus), -ECHILD);
2842 r = bus_match_parse(match, &components, &n_components);
2846 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2852 s->match_callback.callback = callback;
2853 s->match_callback.cookie = ++bus->match_cookie;
2855 if (bus->bus_client) {
2857 if (!bus->is_kernel) {
2858 /* When this is not a kernel transport, we
2859 * store the original match string, so that we
2860 * can use it to remove the match again */
2862 s->match_callback.match_string = strdup(match);
2863 if (!s->match_callback.match_string) {
2869 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2874 bus->match_callbacks_modified = true;
2875 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2884 bus_match_parse_free(components, n_components);
2885 sd_bus_slot_unref(s);
2890 int bus_remove_match_by_string(
2893 sd_bus_message_handler_t callback,
2896 struct bus_match_component *components = NULL;
2897 unsigned n_components = 0;
2898 struct match_callback *c;
2901 assert_return(bus, -EINVAL);
2902 assert_return(match, -EINVAL);
2903 assert_return(!bus_pid_changed(bus), -ECHILD);
2905 r = bus_match_parse(match, &components, &n_components);
2909 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2913 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2916 bus_match_parse_free(components, n_components);
2921 bool bus_pid_changed(sd_bus *bus) {
2924 /* We don't support people creating a bus connection and
2925 * keeping it around over a fork(). Let's complain. */
2927 return bus->original_pid != getpid();
2930 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2931 sd_bus *bus = userdata;
2936 r = sd_bus_process(bus, NULL);
2943 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2944 sd_bus *bus = userdata;
2949 r = sd_bus_process(bus, NULL);
2956 static int prepare_callback(sd_event_source *s, void *userdata) {
2957 sd_bus *bus = userdata;
2964 e = sd_bus_get_events(bus);
2968 if (bus->output_fd != bus->input_fd) {
2970 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2974 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2978 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2983 r = sd_bus_get_timeout(bus, &until);
2989 j = sd_event_source_set_time(bus->time_event_source, until);
2994 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3001 static int quit_callback(sd_event_source *event, void *userdata) {
3002 sd_bus *bus = userdata;
3012 static int attach_io_events(sd_bus *bus) {
3017 if (bus->input_fd < 0)
3023 if (!bus->input_io_event_source) {
3024 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3028 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3032 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3036 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3038 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3043 if (bus->output_fd != bus->input_fd) {
3044 assert(bus->output_fd >= 0);
3046 if (!bus->output_io_event_source) {
3047 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3051 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3055 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3057 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3066 static void detach_io_events(sd_bus *bus) {
3069 if (bus->input_io_event_source) {
3070 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3071 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3074 if (bus->output_io_event_source) {
3075 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3076 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3080 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3083 assert_return(bus, -EINVAL);
3084 assert_return(!bus->event, -EBUSY);
3086 assert(!bus->input_io_event_source);
3087 assert(!bus->output_io_event_source);
3088 assert(!bus->time_event_source);
3091 bus->event = sd_event_ref(event);
3093 r = sd_event_default(&bus->event);
3098 bus->event_priority = priority;
3100 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3104 r = sd_event_source_set_priority(bus->time_event_source, priority);
3108 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3112 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3116 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3120 r = attach_io_events(bus);
3127 sd_bus_detach_event(bus);
3131 _public_ int sd_bus_detach_event(sd_bus *bus) {
3132 assert_return(bus, -EINVAL);
3137 detach_io_events(bus);
3139 if (bus->time_event_source) {
3140 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3141 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3144 if (bus->quit_event_source) {
3145 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3146 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3149 bus->event = sd_event_unref(bus->event);
3153 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3154 assert_return(bus, NULL);
3159 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3160 assert_return(bus, NULL);
3162 return bus->current_message;
3165 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3166 assert_return(bus, NULL);
3168 return bus->current_slot;
3171 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3172 assert_return(bus, NULL);
3174 return bus->current_handler;
3177 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3178 assert_return(bus, NULL);
3180 return bus->current_userdata;
3183 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3188 assert(default_bus);
3191 return !!*default_bus;
3194 *ret = sd_bus_ref(*default_bus);
3202 b->default_bus_ptr = default_bus;
3210 _public_ int sd_bus_default_system(sd_bus **ret) {
3211 static thread_local sd_bus *default_system_bus = NULL;
3213 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3216 _public_ int sd_bus_default_user(sd_bus **ret) {
3217 static thread_local sd_bus *default_user_bus = NULL;
3219 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3222 _public_ int sd_bus_default(sd_bus **ret) {
3226 /* Let's try our best to reuse another cached connection. If
3227 * the starter bus type is set, connect via our normal
3228 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3229 * we can share the connection with the user/system default
3232 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3234 if (streq(e, "system"))
3235 return sd_bus_default_system(ret);
3236 else if (STR_IN_SET(e, "user", "session"))
3237 return sd_bus_default_user(ret);
3240 /* No type is specified, so we have not other option than to
3241 * use the starter address if it is set. */
3243 e = secure_getenv("DBUS_STARTER_ADDRESS");
3245 static thread_local sd_bus *default_starter_bus = NULL;
3247 return bus_default(sd_bus_open, &default_starter_bus, ret);
3250 /* Finally, if nothing is set use the cached connection for
3251 * the right scope */
3253 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3254 return sd_bus_default_user(ret);
3256 return sd_bus_default_system(ret);
3259 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3260 assert_return(b, -EINVAL);
3261 assert_return(tid, -EINVAL);
3262 assert_return(!bus_pid_changed(b), -ECHILD);
3270 return sd_event_get_tid(b->event, tid);
3275 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3276 _cleanup_free_ char *e = NULL;
3279 assert_return(object_path_is_valid(prefix), -EINVAL);
3280 assert_return(external_id, -EINVAL);
3281 assert_return(ret_path, -EINVAL);
3283 e = bus_label_escape(external_id);
3287 ret = strjoin(prefix, "/", e, NULL);
3295 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3299 assert_return(object_path_is_valid(path), -EINVAL);
3300 assert_return(object_path_is_valid(prefix), -EINVAL);
3301 assert_return(external_id, -EINVAL);
3303 e = object_path_startswith(path, prefix);
3305 *external_id = NULL;
3309 ret = bus_label_unescape(e);
3317 _public_ int sd_bus_try_close(sd_bus *bus) {
3320 assert_return(bus, -EINVAL);
3321 assert_return(!bus_pid_changed(bus), -ECHILD);
3323 if (!bus->is_kernel)
3326 if (!BUS_IS_OPEN(bus->state))
3329 if (bus->rqueue_size > 0)
3332 if (bus->wqueue_size > 0)
3335 r = bus_kernel_try_close(bus);
3343 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3344 assert_return(bus, -EINVAL);
3345 assert_return(description, -EINVAL);
3346 assert_return(bus->description, -ENXIO);
3347 assert_return(!bus_pid_changed(bus), -ECHILD);
3349 *description = bus->description;
3353 int bus_get_root_path(sd_bus *bus) {
3356 if (bus->cgroup_root)
3359 r = cg_get_root_path(&bus->cgroup_root);
3361 bus->cgroup_root = strdup("/");
3362 if (!bus->cgroup_root)