1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
38 #include "cgroup-util.h"
39 #include "bus-label.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
54 #include "bus-track.h"
57 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
58 static int attach_io_events(sd_bus *b);
59 static void detach_io_events(sd_bus *b);
61 static void bus_close_fds(sd_bus *b) {
67 safe_close(b->input_fd);
69 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
70 safe_close(b->output_fd);
72 b->input_fd = b->output_fd = -1;
75 static void bus_reset_queues(sd_bus *b) {
78 while (b->rqueue_size > 0)
79 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
83 b->rqueue_allocated = 0;
85 while (b->wqueue_size > 0)
86 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
90 b->wqueue_allocated = 0;
93 static void bus_free(sd_bus *b) {
97 assert(!b->track_queue);
99 b->state = BUS_CLOSED;
101 sd_bus_detach_event(b);
103 while ((s = b->slots)) {
104 /* At this point only floating slots can still be
105 * around, because the non-floating ones keep a
106 * reference to the bus, and we thus couldn't be
107 * destructing right now... We forcibly disconnect the
108 * slots here, so that they still can be referenced by
109 * apps, but are dead. */
112 bus_slot_disconnect(s);
113 sd_bus_slot_unref(s);
116 if (b->default_bus_ptr)
117 *b->default_bus_ptr = NULL;
122 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
125 free(b->unique_name);
126 free(b->auth_buffer);
131 free(b->cgroup_root);
132 free(b->connection_name);
135 strv_free(b->exec_argv);
137 close_many(b->fds, b->n_fds);
142 hashmap_free_free(b->reply_callbacks);
143 prioq_free(b->reply_callbacks_prioq);
145 bus_match_free(&b->match_callbacks);
147 hashmap_free_free(b->vtable_methods);
148 hashmap_free_free(b->vtable_properties);
150 assert(hashmap_isempty(b->nodes));
151 hashmap_free(b->nodes);
153 bus_kernel_flush_memfd(b);
155 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
160 _public_ int sd_bus_new(sd_bus **ret) {
163 assert_return(ret, -EINVAL);
169 r->n_ref = REFCNT_INIT;
170 r->input_fd = r->output_fd = -1;
171 r->message_version = 1;
172 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
173 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
174 r->attach_flags |= KDBUS_ATTACH_NAMES;
175 r->original_pid = getpid();
177 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
179 /* We guarantee that wqueue always has space for at least one
181 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
190 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
193 assert_return(bus, -EINVAL);
194 assert_return(bus->state == BUS_UNSET, -EPERM);
195 assert_return(address, -EINVAL);
196 assert_return(!bus_pid_changed(bus), -ECHILD);
208 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
209 assert_return(bus, -EINVAL);
210 assert_return(bus->state == BUS_UNSET, -EPERM);
211 assert_return(input_fd >= 0, -EINVAL);
212 assert_return(output_fd >= 0, -EINVAL);
213 assert_return(!bus_pid_changed(bus), -ECHILD);
215 bus->input_fd = input_fd;
216 bus->output_fd = output_fd;
220 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
223 assert_return(bus, -EINVAL);
224 assert_return(bus->state == BUS_UNSET, -EPERM);
225 assert_return(path, -EINVAL);
226 assert_return(!strv_isempty(argv), -EINVAL);
227 assert_return(!bus_pid_changed(bus), -ECHILD);
239 free(bus->exec_path);
240 strv_free(bus->exec_argv);
248 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
249 assert_return(bus, -EINVAL);
250 assert_return(bus->state == BUS_UNSET, -EPERM);
251 assert_return(!bus_pid_changed(bus), -ECHILD);
253 bus->bus_client = !!b;
257 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
258 assert_return(bus, -EINVAL);
259 assert_return(bus->state == BUS_UNSET, -EPERM);
260 assert_return(!bus_pid_changed(bus), -ECHILD);
262 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
266 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
267 assert_return(bus, -EINVAL);
268 assert_return(bus->state == BUS_UNSET, -EPERM);
269 assert_return(!bus_pid_changed(bus), -ECHILD);
271 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
275 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
276 assert_return(bus, -EINVAL);
277 assert_return(bus->state == BUS_UNSET, -EPERM);
278 assert_return(!bus_pid_changed(bus), -ECHILD);
280 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
284 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
285 assert_return(bus, -EINVAL);
286 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
287 assert_return(bus->state == BUS_UNSET, -EPERM);
288 assert_return(!bus_pid_changed(bus), -ECHILD);
290 /* The well knowns we need unconditionally, so that matches can work */
291 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
293 return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags);
296 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
297 assert_return(bus, -EINVAL);
298 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
299 assert_return(bus->state == BUS_UNSET, -EPERM);
300 assert_return(!bus_pid_changed(bus), -ECHILD);
302 bus->is_server = !!b;
303 bus->server_id = server_id;
307 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
308 assert_return(bus, -EINVAL);
309 assert_return(bus->state == BUS_UNSET, -EPERM);
310 assert_return(!bus_pid_changed(bus), -ECHILD);
312 bus->anonymous_auth = !!b;
316 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
317 assert_return(bus, -EINVAL);
318 assert_return(bus->state == BUS_UNSET, -EPERM);
319 assert_return(!bus_pid_changed(bus), -ECHILD);
325 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
328 assert_return(bus, -EINVAL);
329 assert_return(name, -EINVAL);
330 assert_return(bus->state == BUS_UNSET, -EPERM);
331 assert_return(!bus_pid_changed(bus), -ECHILD);
337 free(bus->connection_name);
338 bus->connection_name = n;
343 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
348 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
351 r = sd_bus_message_get_errno(reply);
357 r = sd_bus_message_read(reply, "s", &s);
361 if (!service_name_is_valid(s) || s[0] != ':')
364 bus->unique_name = strdup(s);
365 if (!bus->unique_name)
368 if (bus->state == BUS_HELLO)
369 bus->state = BUS_RUNNING;
374 static int bus_send_hello(sd_bus *bus) {
375 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
380 if (!bus->bus_client || bus->is_kernel)
383 r = sd_bus_message_new_method_call(
386 "org.freedesktop.DBus",
387 "/org/freedesktop/DBus",
388 "org.freedesktop.DBus",
393 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
396 int bus_start_running(sd_bus *bus) {
399 if (bus->bus_client && !bus->is_kernel) {
400 bus->state = BUS_HELLO;
404 bus->state = BUS_RUNNING;
408 static int parse_address_key(const char **p, const char *key, char **value) {
409 size_t l, n = 0, allocated = 0;
419 if (strncmp(*p, key, l) != 0)
432 while (*a != ';' && *a != ',' && *a != 0) {
450 c = (char) ((x << 4) | y);
457 if (!GREEDY_REALLOC(r, allocated, n + 2))
481 static void skip_address_key(const char **p) {
485 *p += strcspn(*p, ",");
491 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
492 _cleanup_free_ char *path = NULL, *abstract = NULL;
501 while (**p != 0 && **p != ';') {
502 r = parse_address_key(p, "guid", guid);
508 r = parse_address_key(p, "path", &path);
514 r = parse_address_key(p, "abstract", &abstract);
523 if (!path && !abstract)
526 if (path && abstract)
531 if (l > sizeof(b->sockaddr.un.sun_path))
534 b->sockaddr.un.sun_family = AF_UNIX;
535 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
536 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
537 } else if (abstract) {
538 l = strlen(abstract);
539 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
542 b->sockaddr.un.sun_family = AF_UNIX;
543 b->sockaddr.un.sun_path[0] = 0;
544 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
545 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
551 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
552 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
554 struct addrinfo *result, hints = {
555 .ai_socktype = SOCK_STREAM,
556 .ai_flags = AI_ADDRCONFIG,
564 while (**p != 0 && **p != ';') {
565 r = parse_address_key(p, "guid", guid);
571 r = parse_address_key(p, "host", &host);
577 r = parse_address_key(p, "port", &port);
583 r = parse_address_key(p, "family", &family);
596 if (streq(family, "ipv4"))
597 hints.ai_family = AF_INET;
598 else if (streq(family, "ipv6"))
599 hints.ai_family = AF_INET6;
604 r = getaddrinfo(host, port, &hints, &result);
608 return -EADDRNOTAVAIL;
610 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
611 b->sockaddr_size = result->ai_addrlen;
613 freeaddrinfo(result);
618 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
620 unsigned n_argv = 0, j;
622 size_t allocated = 0;
630 while (**p != 0 && **p != ';') {
631 r = parse_address_key(p, "guid", guid);
637 r = parse_address_key(p, "path", &path);
643 if (startswith(*p, "argv")) {
647 ul = strtoul(*p + 4, (char**) p, 10);
648 if (errno > 0 || **p != '=' || ul > 256) {
656 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
664 r = parse_address_key(p, NULL, argv + ul);
679 /* Make sure there are no holes in the array, with the
680 * exception of argv[0] */
681 for (j = 1; j < n_argv; j++)
687 if (argv && argv[0] == NULL) {
688 argv[0] = strdup(path);
700 for (j = 0; j < n_argv; j++)
708 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
709 _cleanup_free_ char *path = NULL;
717 while (**p != 0 && **p != ';') {
718 r = parse_address_key(p, "guid", guid);
724 r = parse_address_key(p, "path", &path);
743 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
744 _cleanup_free_ char *machine = NULL;
752 while (**p != 0 && **p != ';') {
753 r = parse_address_key(p, "guid", guid);
759 r = parse_address_key(p, "machine", &machine);
771 if (!filename_is_safe(machine))
775 b->machine = machine;
778 b->sockaddr.un.sun_family = AF_UNIX;
779 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
780 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
785 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
786 _cleanup_free_ char *machine = NULL;
794 while (**p != 0 && **p != ';') {
795 r = parse_address_key(p, "guid", guid);
801 r = parse_address_key(p, "machine", &machine);
813 if (!filename_is_safe(machine))
817 b->machine = machine;
821 b->kernel = strdup("/dev/kdbus/0-system/bus");
828 static void bus_reset_parsed_address(sd_bus *b) {
832 b->sockaddr_size = 0;
833 strv_free(b->exec_argv);
837 b->server_id = SD_ID128_NULL;
844 static int bus_parse_next_address(sd_bus *b) {
845 _cleanup_free_ char *guid = NULL;
853 if (b->address[b->address_index] == 0)
856 bus_reset_parsed_address(b);
858 a = b->address + b->address_index;
867 if (startswith(a, "unix:")) {
870 r = parse_unix_address(b, &a, &guid);
875 } else if (startswith(a, "tcp:")) {
878 r = parse_tcp_address(b, &a, &guid);
884 } else if (startswith(a, "unixexec:")) {
887 r = parse_exec_address(b, &a, &guid);
893 } else if (startswith(a, "kernel:")) {
896 r = parse_kernel_address(b, &a, &guid);
901 } else if (startswith(a, "x-container-unix:")) {
904 r = parse_container_unix_address(b, &a, &guid);
909 } else if (startswith(a, "x-container-kernel:")) {
912 r = parse_container_kernel_address(b, &a, &guid);
925 r = sd_id128_from_string(guid, &b->server_id);
930 b->address_index = a - b->address;
934 static int bus_start_address(sd_bus *b) {
940 bool skipped = false;
945 r = bus_socket_exec(b);
946 else if (b->machine && b->kernel)
947 r = bus_container_connect_kernel(b);
948 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
949 r = bus_container_connect_socket(b);
951 r = bus_kernel_connect(b);
952 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
953 r = bus_socket_connect(b);
959 r = attach_io_events(b);
964 b->last_connect_error = -r;
967 r = bus_parse_next_address(b);
971 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
975 int bus_next_address(sd_bus *b) {
978 bus_reset_parsed_address(b);
979 return bus_start_address(b);
982 static int bus_start_fd(sd_bus *b) {
987 assert(b->input_fd >= 0);
988 assert(b->output_fd >= 0);
990 r = fd_nonblock(b->input_fd, true);
994 r = fd_cloexec(b->input_fd, true);
998 if (b->input_fd != b->output_fd) {
999 r = fd_nonblock(b->output_fd, true);
1003 r = fd_cloexec(b->output_fd, true);
1008 if (fstat(b->input_fd, &st) < 0)
1011 if (S_ISCHR(b->input_fd))
1012 return bus_kernel_take_fd(b);
1014 return bus_socket_take_fd(b);
1017 _public_ int sd_bus_start(sd_bus *bus) {
1020 assert_return(bus, -EINVAL);
1021 assert_return(bus->state == BUS_UNSET, -EPERM);
1022 assert_return(!bus_pid_changed(bus), -ECHILD);
1024 bus->state = BUS_OPENING;
1026 if (bus->is_server && bus->bus_client)
1029 if (bus->input_fd >= 0)
1030 r = bus_start_fd(bus);
1031 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1032 r = bus_start_address(bus);
1039 return bus_send_hello(bus);
1042 _public_ int sd_bus_open(sd_bus **ret) {
1047 assert_return(ret, -EINVAL);
1049 /* Let's connect to the starter bus if it is set, and
1050 * otherwise to the bus that is appropropriate for the scope
1051 * we are running in */
1053 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1055 if (streq(e, "system"))
1056 return sd_bus_open_system(ret);
1057 else if (STR_IN_SET(e, "session", "user"))
1058 return sd_bus_open_user(ret);
1061 e = secure_getenv("DBUS_STARTER_ADDRESS");
1063 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1064 return sd_bus_open_user(ret);
1066 return sd_bus_open_system(ret);
1073 r = sd_bus_set_address(b, e);
1077 b->bus_client = true;
1079 /* We don't know whether the bus is trusted or not, so better
1080 * be safe, and authenticate everything */
1082 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1084 r = sd_bus_start(b);
1096 int bus_set_address_system(sd_bus *b) {
1100 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1102 return sd_bus_set_address(b, e);
1104 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1107 _public_ int sd_bus_open_system(sd_bus **ret) {
1111 assert_return(ret, -EINVAL);
1117 r = bus_set_address_system(b);
1121 b->bus_client = true;
1122 b->is_system = true;
1124 /* Let's do per-method access control on the system bus. We
1125 * need the caller's UID and capability set for that. */
1127 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1129 r = sd_bus_start(b);
1141 int bus_set_address_user(sd_bus *b) {
1146 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1148 return sd_bus_set_address(b, e);
1150 e = secure_getenv("XDG_RUNTIME_DIR");
1152 _cleanup_free_ char *ee = NULL;
1154 ee = bus_address_escape(e);
1159 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1161 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1165 asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1167 return -ECONNREFUSED;
1177 _public_ int sd_bus_open_user(sd_bus **ret) {
1181 assert_return(ret, -EINVAL);
1187 r = bus_set_address_user(b);
1191 b->bus_client = true;
1194 /* We don't do any per-method access control on the user
1198 r = sd_bus_start(b);
1210 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1211 _cleanup_free_ char *e = NULL;
1216 e = bus_address_escape(host);
1220 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1227 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1231 assert_return(host, -EINVAL);
1232 assert_return(ret, -EINVAL);
1234 r = sd_bus_new(&bus);
1238 r = bus_set_address_system_remote(bus, host);
1242 bus->bus_client = true;
1243 bus->trusted = false;
1245 r = sd_bus_start(bus);
1257 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1258 _cleanup_free_ char *e = NULL;
1263 e = bus_address_escape(machine);
1268 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1270 b->address = strjoin("x-container-unix:machine=", e, NULL);
1278 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1282 assert_return(machine, -EINVAL);
1283 assert_return(ret, -EINVAL);
1284 assert_return(filename_is_safe(machine), -EINVAL);
1286 r = sd_bus_new(&bus);
1290 r = bus_set_address_system_container(bus, machine);
1294 bus->bus_client = true;
1295 bus->trusted = false;
1297 r = sd_bus_start(bus);
1309 _public_ void sd_bus_close(sd_bus *bus) {
1313 if (bus->state == BUS_CLOSED)
1315 if (bus_pid_changed(bus))
1318 bus->state = BUS_CLOSED;
1320 sd_bus_detach_event(bus);
1322 /* Drop all queued messages so that they drop references to
1323 * the bus object and the bus may be freed */
1324 bus_reset_queues(bus);
1326 if (!bus->is_kernel)
1329 /* We'll leave the fd open in case this is a kernel bus, since
1330 * there might still be memblocks around that reference this
1331 * bus, and they might need to invoke the KDBUS_CMD_FREE
1332 * ioctl on the fd when they are freed. */
1335 static void bus_enter_closing(sd_bus *bus) {
1338 if (bus->state != BUS_OPENING &&
1339 bus->state != BUS_AUTHENTICATING &&
1340 bus->state != BUS_HELLO &&
1341 bus->state != BUS_RUNNING)
1344 bus->state = BUS_CLOSING;
1347 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1348 assert_return(bus, NULL);
1350 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1355 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1361 i = REFCNT_DEC(bus->n_ref);
1369 _public_ int sd_bus_is_open(sd_bus *bus) {
1371 assert_return(bus, -EINVAL);
1372 assert_return(!bus_pid_changed(bus), -ECHILD);
1374 return BUS_IS_OPEN(bus->state);
1377 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1380 assert_return(bus, -EINVAL);
1381 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1382 assert_return(!bus_pid_changed(bus), -ECHILD);
1384 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1387 if (type == SD_BUS_TYPE_UNIX_FD) {
1388 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1391 r = bus_ensure_running(bus);
1395 return bus->can_fds;
1398 return bus_type_is_valid(type);
1401 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1404 assert_return(bus, -EINVAL);
1405 assert_return(server_id, -EINVAL);
1406 assert_return(!bus_pid_changed(bus), -ECHILD);
1408 r = bus_ensure_running(bus);
1412 *server_id = bus->server_id;
1416 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1421 /* If we copy the same message to multiple
1422 * destinations, avoid using the same cookie
1424 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1429 timeout = BUS_DEFAULT_TIMEOUT;
1431 return bus_message_seal(m, ++b->cookie, timeout);
1434 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1437 /* Do packet version and endianness already match? */
1438 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1439 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1442 /* No? Then remarshal! */
1443 return bus_message_remarshal(b, m);
1446 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1450 /* The bus specification says the serial number cannot be 0,
1451 * hence let's fill something in for synthetic messages. Since
1452 * synthetic messages might have a fake sender and we don't
1453 * want to interfere with the real sender's serial numbers we
1454 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1455 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1456 * even though kdbus can do 64bit. */
1458 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1461 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1468 r = bus_kernel_write_message(bus, m, hint_sync_call);
1470 r = bus_socket_write_message(bus, m, idx);
1475 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1476 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1477 bus_message_type_to_string(m->header->type),
1478 strna(sd_bus_message_get_sender(m)),
1479 strna(sd_bus_message_get_destination(m)),
1480 strna(sd_bus_message_get_path(m)),
1481 strna(sd_bus_message_get_interface(m)),
1482 strna(sd_bus_message_get_member(m)),
1483 BUS_MESSAGE_COOKIE(m),
1485 strna(m->error.message));
1490 static int dispatch_wqueue(sd_bus *bus) {
1494 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1496 while (bus->wqueue_size > 0) {
1498 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1502 /* Didn't do anything this time */
1504 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1505 /* Fully written. Let's drop the entry from
1508 * This isn't particularly optimized, but
1509 * well, this is supposed to be our worst-case
1510 * buffer only, and the socket buffer is
1511 * supposed to be our primary buffer, and if
1512 * it got full, then all bets are off
1515 bus->wqueue_size --;
1516 sd_bus_message_unref(bus->wqueue[0]);
1517 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1527 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1531 return bus_kernel_read_message(bus, hint_priority, priority);
1533 return bus_socket_read_message(bus);
1536 int bus_rqueue_make_room(sd_bus *bus) {
1539 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1542 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1548 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1553 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1555 /* Note that the priority logic is only available on kdbus,
1556 * where the rqueue is unused. We check the rqueue here
1557 * anyway, because it's simple... */
1560 if (bus->rqueue_size > 0) {
1561 /* Dispatch a queued message */
1563 *m = bus->rqueue[0];
1564 bus->rqueue_size --;
1565 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1569 /* Try to read a new message */
1570 r = bus_read_message(bus, hint_priority, priority);
1580 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1581 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1584 assert_return(bus, -EINVAL);
1585 assert_return(m, -EINVAL);
1586 assert_return(!bus_pid_changed(bus), -ECHILD);
1587 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1589 if (!BUS_IS_OPEN(bus->state))
1593 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1600 /* If the cookie number isn't kept, then we know that no reply
1602 if (!cookie && !m->sealed)
1603 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1605 r = bus_seal_message(bus, m, 0);
1609 /* Remarshall if we have to. This will possibly unref the
1610 * message and place a replacement in m */
1611 r = bus_remarshal_message(bus, &m);
1615 /* If this is a reply and no reply was requested, then let's
1616 * suppress this, if we can */
1617 if (m->dont_send && !cookie)
1620 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1623 r = bus_write_message(bus, m, hint_sync_call, &idx);
1625 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1626 bus_enter_closing(bus);
1631 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1632 /* Wasn't fully written. So let's remember how
1633 * much was written. Note that the first entry
1634 * of the wqueue array is always allocated so
1635 * that we always can remember how much was
1637 bus->wqueue[0] = sd_bus_message_ref(m);
1638 bus->wqueue_size = 1;
1642 /* Just append it to the queue. */
1644 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1647 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1650 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1654 *cookie = BUS_MESSAGE_COOKIE(m);
1659 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1660 return bus_send_internal(bus, m, cookie, false);
1663 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1666 assert_return(bus, -EINVAL);
1667 assert_return(m, -EINVAL);
1668 assert_return(!bus_pid_changed(bus), -ECHILD);
1670 if (!BUS_IS_OPEN(bus->state))
1673 if (!streq_ptr(m->destination, destination)) {
1678 r = sd_bus_message_set_destination(m, destination);
1683 return sd_bus_send(bus, m, cookie);
1686 static usec_t calc_elapse(uint64_t usec) {
1687 if (usec == (uint64_t) -1)
1690 return now(CLOCK_MONOTONIC) + usec;
1693 static int timeout_compare(const void *a, const void *b) {
1694 const struct reply_callback *x = a, *y = b;
1696 if (x->timeout != 0 && y->timeout == 0)
1699 if (x->timeout == 0 && y->timeout != 0)
1702 if (x->timeout < y->timeout)
1705 if (x->timeout > y->timeout)
1711 _public_ int sd_bus_call_async(
1715 sd_bus_message_handler_t callback,
1719 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1720 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1723 assert_return(bus, -EINVAL);
1724 assert_return(m, -EINVAL);
1725 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1726 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1727 assert_return(callback, -EINVAL);
1728 assert_return(!bus_pid_changed(bus), -ECHILD);
1729 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1731 if (!BUS_IS_OPEN(bus->state))
1734 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1738 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1742 r = bus_seal_message(bus, m, usec);
1746 r = bus_remarshal_message(bus, &m);
1750 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1754 s->reply_callback.callback = callback;
1756 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1757 r = hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1759 s->reply_callback.cookie = 0;
1763 s->reply_callback.timeout = calc_elapse(m->timeout);
1764 if (s->reply_callback.timeout != 0) {
1765 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1767 s->reply_callback.timeout = 0;
1772 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1783 int bus_ensure_running(sd_bus *bus) {
1788 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1790 if (bus->state == BUS_RUNNING)
1794 r = sd_bus_process(bus, NULL);
1797 if (bus->state == BUS_RUNNING)
1802 r = sd_bus_wait(bus, (uint64_t) -1);
1808 _public_ int sd_bus_call(
1812 sd_bus_error *error,
1813 sd_bus_message **reply) {
1815 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1821 assert_return(bus, -EINVAL);
1822 assert_return(m, -EINVAL);
1823 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1824 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1825 assert_return(!bus_error_is_dirty(error), -EINVAL);
1826 assert_return(!bus_pid_changed(bus), -ECHILD);
1827 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1829 if (!BUS_IS_OPEN(bus->state))
1832 r = bus_ensure_running(bus);
1836 i = bus->rqueue_size;
1838 r = bus_seal_message(bus, m, usec);
1842 r = bus_remarshal_message(bus, &m);
1846 r = bus_send_internal(bus, m, &cookie, true);
1850 timeout = calc_elapse(m->timeout);
1855 while (i < bus->rqueue_size) {
1856 sd_bus_message *incoming = NULL;
1858 incoming = bus->rqueue[i];
1860 if (incoming->reply_cookie == cookie) {
1861 /* Found a match! */
1863 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1866 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1868 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1872 sd_bus_message_unref(incoming);
1877 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1879 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1880 r = sd_bus_error_copy(error, &incoming->error);
1884 sd_bus_message_unref(incoming);
1887 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1890 streq(bus->unique_name, incoming->sender)) {
1892 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1895 /* Our own message? Somebody is trying
1896 * to send its own client a message,
1897 * let's not dead-lock, let's fail
1900 sd_bus_message_unref(incoming);
1904 /* Try to read more, right-away */
1908 r = bus_read_message(bus, false, 0);
1910 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1911 bus_enter_closing(bus);
1923 n = now(CLOCK_MONOTONIC);
1929 left = (uint64_t) -1;
1931 r = bus_poll(bus, true, left);
1937 r = dispatch_wqueue(bus);
1939 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1940 bus_enter_closing(bus);
1949 _public_ int sd_bus_get_fd(sd_bus *bus) {
1951 assert_return(bus, -EINVAL);
1952 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1953 assert_return(!bus_pid_changed(bus), -ECHILD);
1955 return bus->input_fd;
1958 _public_ int sd_bus_get_events(sd_bus *bus) {
1961 assert_return(bus, -EINVAL);
1962 assert_return(!bus_pid_changed(bus), -ECHILD);
1964 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1967 if (bus->state == BUS_OPENING)
1969 else if (bus->state == BUS_AUTHENTICATING) {
1971 if (bus_socket_auth_needs_write(bus))
1976 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1977 if (bus->rqueue_size <= 0)
1979 if (bus->wqueue_size > 0)
1986 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1987 struct reply_callback *c;
1989 assert_return(bus, -EINVAL);
1990 assert_return(timeout_usec, -EINVAL);
1991 assert_return(!bus_pid_changed(bus), -ECHILD);
1993 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1996 if (bus->track_queue) {
2001 if (bus->state == BUS_CLOSING) {
2006 if (bus->state == BUS_AUTHENTICATING) {
2007 *timeout_usec = bus->auth_timeout;
2011 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2012 *timeout_usec = (uint64_t) -1;
2016 if (bus->rqueue_size > 0) {
2021 c = prioq_peek(bus->reply_callbacks_prioq);
2023 *timeout_usec = (uint64_t) -1;
2027 if (c->timeout == 0) {
2028 *timeout_usec = (uint64_t) -1;
2032 *timeout_usec = c->timeout;
2036 static int process_timeout(sd_bus *bus) {
2037 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2038 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2039 struct reply_callback *c;
2046 c = prioq_peek(bus->reply_callbacks_prioq);
2050 n = now(CLOCK_MONOTONIC);
2054 r = bus_message_new_synthetic_error(
2057 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2062 m->sender = "org.freedesktop.DBus";
2064 r = bus_seal_synthetic_message(bus, m);
2068 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2071 hashmap_remove(bus->reply_callbacks, &c->cookie);
2074 slot = container_of(c, sd_bus_slot, reply_callback);
2076 bus->iteration_counter ++;
2078 bus->current_message = m;
2079 bus->current_slot = sd_bus_slot_ref(slot);
2080 r = c->callback(bus, m, slot->userdata, &error_buffer);
2081 bus->current_slot = sd_bus_slot_unref(slot);
2082 bus->current_message = NULL;
2084 if (slot->floating) {
2085 bus_slot_disconnect(slot);
2086 sd_bus_slot_unref(slot);
2089 return bus_maybe_reply_error(m, r, &error_buffer);
2092 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2096 if (bus->state != BUS_HELLO)
2099 /* Let's make sure the first message on the bus is the HELLO
2100 * reply. But note that we don't actually parse the message
2101 * here (we leave that to the usual handling), we just verify
2102 * we don't let any earlier msg through. */
2104 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2105 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2108 if (m->reply_cookie != 1)
2114 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2115 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2116 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2117 struct reply_callback *c;
2124 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2125 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2128 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2131 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2134 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2140 slot = container_of(c, sd_bus_slot, reply_callback);
2142 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2144 /* If the reply contained a file descriptor which we
2145 * didn't want we pass an error instead. */
2147 r = bus_message_new_synthetic_error(
2150 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2155 r = bus_seal_synthetic_message(bus, synthetic_reply);
2159 m = synthetic_reply;
2161 r = sd_bus_message_rewind(m, true);
2166 if (c->timeout != 0) {
2167 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2171 bus->current_slot = sd_bus_slot_ref(slot);
2172 r = c->callback(bus, m, slot->userdata, &error_buffer);
2173 bus->current_slot = sd_bus_slot_unref(slot);
2175 if (slot->floating) {
2176 bus_slot_disconnect(slot);
2177 sd_bus_slot_unref(slot);
2180 return bus_maybe_reply_error(m, r, &error_buffer);
2183 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2184 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2185 struct filter_callback *l;
2192 bus->filter_callbacks_modified = false;
2194 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2197 if (bus->filter_callbacks_modified)
2200 /* Don't run this more than once per iteration */
2201 if (l->last_iteration == bus->iteration_counter)
2204 l->last_iteration = bus->iteration_counter;
2206 r = sd_bus_message_rewind(m, true);
2210 slot = container_of(l, sd_bus_slot, filter_callback);
2212 bus->current_slot = sd_bus_slot_ref(slot);
2213 r = l->callback(bus, m, slot->userdata, &error_buffer);
2214 bus->current_slot = sd_bus_slot_unref(slot);
2216 r = bus_maybe_reply_error(m, r, &error_buffer);
2222 } while (bus->filter_callbacks_modified);
2227 static int process_match(sd_bus *bus, sd_bus_message *m) {
2234 bus->match_callbacks_modified = false;
2236 r = bus_match_run(bus, &bus->match_callbacks, m);
2240 } while (bus->match_callbacks_modified);
2245 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2246 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2252 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2255 if (bus->manual_peer_interface)
2258 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2261 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2264 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2267 if (streq_ptr(m->member, "Ping"))
2268 r = sd_bus_message_new_method_return(m, &reply);
2269 else if (streq_ptr(m->member, "GetMachineId")) {
2273 r = sd_id128_get_machine(&id);
2277 r = sd_bus_message_new_method_return(m, &reply);
2281 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2283 r = sd_bus_message_new_method_errorf(
2285 SD_BUS_ERROR_UNKNOWN_METHOD,
2286 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2292 r = sd_bus_send(bus, reply, NULL);
2299 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2303 /* If we got a message with a file descriptor which we didn't
2304 * want to accept, then let's drop it. How can this even
2305 * happen? For example, when the kernel queues a message into
2306 * an activatable names's queue which allows fds, and then is
2307 * delivered to us later even though we ourselves did not
2310 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2316 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2319 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2320 return 1; /* just eat it up */
2322 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2325 static int process_message(sd_bus *bus, sd_bus_message *m) {
2331 bus->current_message = m;
2332 bus->iteration_counter++;
2334 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2335 bus_message_type_to_string(m->header->type),
2336 strna(sd_bus_message_get_sender(m)),
2337 strna(sd_bus_message_get_destination(m)),
2338 strna(sd_bus_message_get_path(m)),
2339 strna(sd_bus_message_get_interface(m)),
2340 strna(sd_bus_message_get_member(m)),
2341 BUS_MESSAGE_COOKIE(m),
2343 strna(m->error.message));
2345 r = process_hello(bus, m);
2349 r = process_reply(bus, m);
2353 r = process_fd_check(bus, m);
2357 r = process_filter(bus, m);
2361 r = process_match(bus, m);
2365 r = process_builtin(bus, m);
2369 r = bus_process_object(bus, m);
2372 bus->current_message = NULL;
2376 static int dispatch_track(sd_bus *bus) {
2379 if (!bus->track_queue)
2382 bus_track_dispatch(bus->track_queue);
2386 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2387 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2391 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2393 r = process_timeout(bus);
2397 r = dispatch_wqueue(bus);
2401 r = dispatch_track(bus);
2405 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2411 r = process_message(bus, m);
2416 r = sd_bus_message_rewind(m, true);
2425 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2427 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2428 strna(sd_bus_message_get_sender(m)),
2429 strna(sd_bus_message_get_path(m)),
2430 strna(sd_bus_message_get_interface(m)),
2431 strna(sd_bus_message_get_member(m)));
2433 r = sd_bus_reply_method_errorf(
2435 SD_BUS_ERROR_UNKNOWN_OBJECT,
2436 "Unknown object '%s'.", m->path);
2450 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2451 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2452 struct reply_callback *c;
2456 assert(bus->state == BUS_CLOSING);
2458 c = hashmap_first(bus->reply_callbacks);
2460 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2463 /* First, fail all outstanding method calls */
2464 r = bus_message_new_synthetic_error(
2467 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2472 r = bus_seal_synthetic_message(bus, m);
2476 if (c->timeout != 0) {
2477 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2481 hashmap_remove(bus->reply_callbacks, &c->cookie);
2484 slot = container_of(c, sd_bus_slot, reply_callback);
2486 bus->iteration_counter++;
2488 bus->current_message = m;
2489 bus->current_slot = sd_bus_slot_ref(slot);
2490 r = c->callback(bus, m, slot->userdata, &error_buffer);
2491 bus->current_slot = sd_bus_slot_unref(slot);
2492 bus->current_message = NULL;
2494 if (slot->floating) {
2495 bus_slot_disconnect(slot);
2496 sd_bus_slot_unref(slot);
2499 return bus_maybe_reply_error(m, r, &error_buffer);
2502 /* Then, synthesize a Disconnected message */
2503 r = sd_bus_message_new_signal(
2506 "/org/freedesktop/DBus/Local",
2507 "org.freedesktop.DBus.Local",
2512 m->sender = "org.freedesktop.DBus.Local";
2514 r = bus_seal_synthetic_message(bus, m);
2520 bus->current_message = m;
2521 bus->iteration_counter++;
2523 r = process_filter(bus, m);
2527 r = process_match(bus, m);
2539 bus->current_message = NULL;
2544 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2545 BUS_DONT_DESTROY(bus);
2548 /* Returns 0 when we didn't do anything. This should cause the
2549 * caller to invoke sd_bus_wait() before returning the next
2550 * time. Returns > 0 when we did something, which possibly
2551 * means *ret is filled in with an unprocessed message. */
2553 assert_return(bus, -EINVAL);
2554 assert_return(!bus_pid_changed(bus), -ECHILD);
2556 /* We don't allow recursively invoking sd_bus_process(). */
2557 assert_return(!bus->current_message, -EBUSY);
2558 assert(!bus->current_slot);
2560 switch (bus->state) {
2569 r = bus_socket_process_opening(bus);
2570 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2571 bus_enter_closing(bus);
2579 case BUS_AUTHENTICATING:
2580 r = bus_socket_process_authenticating(bus);
2581 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2582 bus_enter_closing(bus);
2594 r = process_running(bus, hint_priority, priority, ret);
2595 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2596 bus_enter_closing(bus);
2606 return process_closing(bus, ret);
2609 assert_not_reached("Unknown state");
2612 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2613 return bus_process_internal(bus, false, 0, ret);
2616 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2617 return bus_process_internal(bus, true, priority, ret);
2620 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2621 struct pollfd p[2] = {};
2624 usec_t m = (usec_t) -1;
2628 if (bus->state == BUS_CLOSING)
2631 if (!BUS_IS_OPEN(bus->state))
2634 e = sd_bus_get_events(bus);
2639 /* The caller really needs some more data, he doesn't
2640 * care about what's already read, or any timeouts
2645 /* The caller wants to process if there's something to
2646 * process, but doesn't care otherwise */
2648 r = sd_bus_get_timeout(bus, &until);
2653 nw = now(CLOCK_MONOTONIC);
2654 m = until > nw ? until - nw : 0;
2658 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2661 p[0].fd = bus->input_fd;
2662 if (bus->output_fd == bus->input_fd) {
2666 p[0].events = e & POLLIN;
2667 p[1].fd = bus->output_fd;
2668 p[1].events = e & POLLOUT;
2672 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2676 return r > 0 ? 1 : 0;
2679 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2681 assert_return(bus, -EINVAL);
2682 assert_return(!bus_pid_changed(bus), -ECHILD);
2684 if (bus->state == BUS_CLOSING)
2687 if (!BUS_IS_OPEN(bus->state))
2690 if (bus->rqueue_size > 0)
2693 return bus_poll(bus, false, timeout_usec);
2696 _public_ int sd_bus_flush(sd_bus *bus) {
2699 assert_return(bus, -EINVAL);
2700 assert_return(!bus_pid_changed(bus), -ECHILD);
2702 if (bus->state == BUS_CLOSING)
2705 if (!BUS_IS_OPEN(bus->state))
2708 r = bus_ensure_running(bus);
2712 if (bus->wqueue_size <= 0)
2716 r = dispatch_wqueue(bus);
2718 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2719 bus_enter_closing(bus);
2726 if (bus->wqueue_size <= 0)
2729 r = bus_poll(bus, false, (uint64_t) -1);
2735 _public_ int sd_bus_add_filter(
2738 sd_bus_message_handler_t callback,
2743 assert_return(bus, -EINVAL);
2744 assert_return(callback, -EINVAL);
2745 assert_return(!bus_pid_changed(bus), -ECHILD);
2747 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2751 s->filter_callback.callback = callback;
2753 bus->filter_callbacks_modified = true;
2754 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2762 _public_ int sd_bus_add_match(
2766 sd_bus_message_handler_t callback,
2769 struct bus_match_component *components = NULL;
2770 unsigned n_components = 0;
2771 sd_bus_slot *s = NULL;
2774 assert_return(bus, -EINVAL);
2775 assert_return(match, -EINVAL);
2776 assert_return(!bus_pid_changed(bus), -ECHILD);
2778 r = bus_match_parse(match, &components, &n_components);
2782 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2788 s->match_callback.callback = callback;
2789 s->match_callback.cookie = ++bus->match_cookie;
2791 if (bus->bus_client) {
2793 if (!bus->is_kernel) {
2794 /* When this is not a kernel transport, we
2795 * store the original match string, so that we
2796 * can use it to remove the match again */
2798 s->match_callback.match_string = strdup(match);
2799 if (!s->match_callback.match_string) {
2805 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2810 bus->match_callbacks_modified = true;
2811 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2820 bus_match_parse_free(components, n_components);
2821 sd_bus_slot_unref(s);
2826 int bus_remove_match_by_string(
2829 sd_bus_message_handler_t callback,
2832 struct bus_match_component *components = NULL;
2833 unsigned n_components = 0;
2834 struct match_callback *c;
2837 assert_return(bus, -EINVAL);
2838 assert_return(match, -EINVAL);
2839 assert_return(!bus_pid_changed(bus), -ECHILD);
2841 r = bus_match_parse(match, &components, &n_components);
2845 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2849 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2852 bus_match_parse_free(components, n_components);
2857 bool bus_pid_changed(sd_bus *bus) {
2860 /* We don't support people creating a bus connection and
2861 * keeping it around over a fork(). Let's complain. */
2863 return bus->original_pid != getpid();
2866 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2867 sd_bus *bus = userdata;
2872 r = sd_bus_process(bus, NULL);
2879 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2880 sd_bus *bus = userdata;
2885 r = sd_bus_process(bus, NULL);
2892 static int prepare_callback(sd_event_source *s, void *userdata) {
2893 sd_bus *bus = userdata;
2900 e = sd_bus_get_events(bus);
2904 if (bus->output_fd != bus->input_fd) {
2906 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2910 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2914 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2919 r = sd_bus_get_timeout(bus, &until);
2925 j = sd_event_source_set_time(bus->time_event_source, until);
2930 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2937 static int quit_callback(sd_event_source *event, void *userdata) {
2938 sd_bus *bus = userdata;
2948 static int attach_io_events(sd_bus *bus) {
2953 if (bus->input_fd < 0)
2959 if (!bus->input_io_event_source) {
2960 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2964 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2968 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2970 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2975 if (bus->output_fd != bus->input_fd) {
2976 assert(bus->output_fd >= 0);
2978 if (!bus->output_io_event_source) {
2979 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
2983 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2985 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2994 static void detach_io_events(sd_bus *bus) {
2997 if (bus->input_io_event_source) {
2998 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2999 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3002 if (bus->output_io_event_source) {
3003 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3004 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3008 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3011 assert_return(bus, -EINVAL);
3012 assert_return(!bus->event, -EBUSY);
3014 assert(!bus->input_io_event_source);
3015 assert(!bus->output_io_event_source);
3016 assert(!bus->time_event_source);
3019 bus->event = sd_event_ref(event);
3021 r = sd_event_default(&bus->event);
3026 bus->event_priority = priority;
3028 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3032 r = sd_event_source_set_priority(bus->time_event_source, priority);
3036 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3040 r = attach_io_events(bus);
3047 sd_bus_detach_event(bus);
3051 _public_ int sd_bus_detach_event(sd_bus *bus) {
3052 assert_return(bus, -EINVAL);
3057 detach_io_events(bus);
3059 if (bus->time_event_source) {
3060 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3061 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3064 if (bus->quit_event_source) {
3065 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3066 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3069 bus->event = sd_event_unref(bus->event);
3073 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3074 assert_return(bus, NULL);
3079 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3080 assert_return(bus, NULL);
3082 return bus->current_message;
3085 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3086 assert_return(bus, NULL);
3088 return bus->current_slot;
3091 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3096 assert(default_bus);
3099 return !!*default_bus;
3102 *ret = sd_bus_ref(*default_bus);
3110 b->default_bus_ptr = default_bus;
3118 _public_ int sd_bus_default_system(sd_bus **ret) {
3119 static thread_local sd_bus *default_system_bus = NULL;
3121 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3124 _public_ int sd_bus_default_user(sd_bus **ret) {
3125 static thread_local sd_bus *default_user_bus = NULL;
3127 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3130 _public_ int sd_bus_default(sd_bus **ret) {
3134 /* Let's try our best to reuse another cached connection. If
3135 * the starter bus type is set, connect via our normal
3136 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3137 * we can share the connection with the user/system default
3140 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3142 if (streq(e, "system"))
3143 return sd_bus_default_system(ret);
3144 else if (STR_IN_SET(e, "user", "session"))
3145 return sd_bus_default_user(ret);
3148 /* No type is specified, so we have not other option than to
3149 * use the starter address if it is set. */
3151 e = secure_getenv("DBUS_STARTER_ADDRESS");
3153 static thread_local sd_bus *default_starter_bus = NULL;
3155 return bus_default(sd_bus_open, &default_starter_bus, ret);
3158 /* Finally, if nothing is set use the cached connection for
3159 * the right scope */
3161 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3162 return sd_bus_default_user(ret);
3164 return sd_bus_default_system(ret);
3167 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3168 assert_return(b, -EINVAL);
3169 assert_return(tid, -EINVAL);
3170 assert_return(!bus_pid_changed(b), -ECHILD);
3178 return sd_event_get_tid(b->event, tid);
3183 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3184 _cleanup_free_ char *e = NULL;
3187 assert_return(object_path_is_valid(prefix), -EINVAL);
3188 assert_return(external_id, -EINVAL);
3189 assert_return(ret_path, -EINVAL);
3191 e = bus_label_escape(external_id);
3195 ret = strjoin(prefix, "/", e, NULL);
3203 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3207 assert_return(object_path_is_valid(path), -EINVAL);
3208 assert_return(object_path_is_valid(prefix), -EINVAL);
3209 assert_return(external_id, -EINVAL);
3211 e = object_path_startswith(path, prefix);
3213 *external_id = NULL;
3217 ret = bus_label_unescape(e);
3225 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3230 assert_return(bus, -EINVAL);
3231 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3232 assert_return(ret, -EINVAL);
3233 assert_return(!bus_pid_changed(bus), -ECHILD);
3238 if (!BUS_IS_OPEN(bus->state))
3241 if (!bus->ucred_valid && !isempty(bus->label))
3244 c = bus_creds_new();
3248 if (bus->ucred_valid) {
3249 pid = c->pid = bus->ucred.pid;
3250 c->uid = bus->ucred.uid;
3251 c->gid = bus->ucred.gid;
3253 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3256 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3257 c->label = strdup(bus->label);
3259 sd_bus_creds_unref(c);
3263 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3266 r = bus_creds_add_more(c, mask, pid, 0);
3274 _public_ int sd_bus_try_close(sd_bus *bus) {
3277 assert_return(bus, -EINVAL);
3278 assert_return(!bus_pid_changed(bus), -ECHILD);
3280 if (!bus->is_kernel)
3283 if (!BUS_IS_OPEN(bus->state))
3286 if (bus->rqueue_size > 0)
3289 if (bus->wqueue_size > 0)
3292 r = bus_kernel_try_close(bus);
3300 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3301 assert_return(bus, -EINVAL);
3302 assert_return(name, -EINVAL);
3303 assert_return(!bus_pid_changed(bus), -ECHILD);
3305 *name = bus->connection_name;