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_ADDRESS);
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_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1180 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1184 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_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;
1286 bus->is_system = true;
1288 r = sd_bus_start(bus);
1300 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1301 _cleanup_free_ char *e = NULL;
1306 e = bus_address_escape(machine);
1311 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1313 b->address = strjoin("x-container-unix:machine=", e, NULL);
1321 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1325 assert_return(machine, -EINVAL);
1326 assert_return(ret, -EINVAL);
1327 assert_return(machine_name_is_valid(machine), -EINVAL);
1329 r = sd_bus_new(&bus);
1333 r = bus_set_address_system_container(bus, machine);
1337 bus->bus_client = true;
1338 bus->trusted = false;
1339 bus->is_system = true;
1341 r = sd_bus_start(bus);
1353 _public_ void sd_bus_close(sd_bus *bus) {
1357 if (bus->state == BUS_CLOSED)
1359 if (bus_pid_changed(bus))
1362 bus->state = BUS_CLOSED;
1364 sd_bus_detach_event(bus);
1366 /* Drop all queued messages so that they drop references to
1367 * the bus object and the bus may be freed */
1368 bus_reset_queues(bus);
1370 if (!bus->is_kernel)
1373 /* We'll leave the fd open in case this is a kernel bus, since
1374 * there might still be memblocks around that reference this
1375 * bus, and they might need to invoke the KDBUS_CMD_FREE
1376 * ioctl on the fd when they are freed. */
1379 static void bus_enter_closing(sd_bus *bus) {
1382 if (bus->state != BUS_OPENING &&
1383 bus->state != BUS_AUTHENTICATING &&
1384 bus->state != BUS_HELLO &&
1385 bus->state != BUS_RUNNING)
1388 bus->state = BUS_CLOSING;
1391 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1392 assert_return(bus, NULL);
1394 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1399 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1405 i = REFCNT_DEC(bus->n_ref);
1413 _public_ int sd_bus_is_open(sd_bus *bus) {
1415 assert_return(bus, -EINVAL);
1416 assert_return(!bus_pid_changed(bus), -ECHILD);
1418 return BUS_IS_OPEN(bus->state);
1421 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1424 assert_return(bus, -EINVAL);
1425 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1426 assert_return(!bus_pid_changed(bus), -ECHILD);
1428 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1431 if (type == SD_BUS_TYPE_UNIX_FD) {
1432 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1435 r = bus_ensure_running(bus);
1439 return bus->can_fds;
1442 return bus_type_is_valid(type);
1445 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1448 assert_return(bus, -EINVAL);
1449 assert_return(id, -EINVAL);
1450 assert_return(!bus_pid_changed(bus), -ECHILD);
1452 r = bus_ensure_running(bus);
1456 *id = bus->server_id;
1460 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1465 /* If we copy the same message to multiple
1466 * destinations, avoid using the same cookie
1468 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1473 timeout = BUS_DEFAULT_TIMEOUT;
1475 return bus_message_seal(m, ++b->cookie, timeout);
1478 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1481 /* Do packet version and endianness already match? */
1482 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1483 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1486 /* No? Then remarshal! */
1487 return bus_message_remarshal(b, m);
1490 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1494 /* The bus specification says the serial number cannot be 0,
1495 * hence let's fill something in for synthetic messages. Since
1496 * synthetic messages might have a fake sender and we don't
1497 * want to interfere with the real sender's serial numbers we
1498 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1499 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1500 * even though kdbus can do 64bit. */
1502 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1505 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1512 r = bus_kernel_write_message(bus, m, hint_sync_call);
1514 r = bus_socket_write_message(bus, m, idx);
1519 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1520 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1521 bus_message_type_to_string(m->header->type),
1522 strna(sd_bus_message_get_sender(m)),
1523 strna(sd_bus_message_get_destination(m)),
1524 strna(sd_bus_message_get_path(m)),
1525 strna(sd_bus_message_get_interface(m)),
1526 strna(sd_bus_message_get_member(m)),
1527 BUS_MESSAGE_COOKIE(m),
1529 strna(m->error.message));
1534 static int dispatch_wqueue(sd_bus *bus) {
1538 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1540 while (bus->wqueue_size > 0) {
1542 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1546 /* Didn't do anything this time */
1548 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1549 /* Fully written. Let's drop the entry from
1552 * This isn't particularly optimized, but
1553 * well, this is supposed to be our worst-case
1554 * buffer only, and the socket buffer is
1555 * supposed to be our primary buffer, and if
1556 * it got full, then all bets are off
1559 bus->wqueue_size --;
1560 sd_bus_message_unref(bus->wqueue[0]);
1561 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1571 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1575 return bus_kernel_read_message(bus, hint_priority, priority);
1577 return bus_socket_read_message(bus);
1580 int bus_rqueue_make_room(sd_bus *bus) {
1583 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1586 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1592 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1597 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1599 /* Note that the priority logic is only available on kdbus,
1600 * where the rqueue is unused. We check the rqueue here
1601 * anyway, because it's simple... */
1604 if (bus->rqueue_size > 0) {
1605 /* Dispatch a queued message */
1607 *m = bus->rqueue[0];
1608 bus->rqueue_size --;
1609 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1613 /* Try to read a new message */
1614 r = bus_read_message(bus, hint_priority, priority);
1624 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1625 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1628 assert_return(bus, -EINVAL);
1629 assert_return(m, -EINVAL);
1630 assert_return(!bus_pid_changed(bus), -ECHILD);
1631 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1633 if (!BUS_IS_OPEN(bus->state))
1637 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1644 /* If the cookie number isn't kept, then we know that no reply
1646 if (!cookie && !m->sealed)
1647 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1649 r = bus_seal_message(bus, m, 0);
1653 /* Remarshall if we have to. This will possibly unref the
1654 * message and place a replacement in m */
1655 r = bus_remarshal_message(bus, &m);
1659 /* If this is a reply and no reply was requested, then let's
1660 * suppress this, if we can */
1661 if (m->dont_send && !cookie)
1664 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1667 r = bus_write_message(bus, m, hint_sync_call, &idx);
1669 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1670 bus_enter_closing(bus);
1675 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1676 /* Wasn't fully written. So let's remember how
1677 * much was written. Note that the first entry
1678 * of the wqueue array is always allocated so
1679 * that we always can remember how much was
1681 bus->wqueue[0] = sd_bus_message_ref(m);
1682 bus->wqueue_size = 1;
1686 /* Just append it to the queue. */
1688 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1691 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1694 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1698 *cookie = BUS_MESSAGE_COOKIE(m);
1703 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1704 return bus_send_internal(bus, m, cookie, false);
1707 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1710 assert_return(bus, -EINVAL);
1711 assert_return(m, -EINVAL);
1712 assert_return(!bus_pid_changed(bus), -ECHILD);
1714 if (!BUS_IS_OPEN(bus->state))
1717 if (!streq_ptr(m->destination, destination)) {
1722 r = sd_bus_message_set_destination(m, destination);
1727 return sd_bus_send(bus, m, cookie);
1730 static usec_t calc_elapse(uint64_t usec) {
1731 if (usec == (uint64_t) -1)
1734 return now(CLOCK_MONOTONIC) + usec;
1737 static int timeout_compare(const void *a, const void *b) {
1738 const struct reply_callback *x = a, *y = b;
1740 if (x->timeout != 0 && y->timeout == 0)
1743 if (x->timeout == 0 && y->timeout != 0)
1746 if (x->timeout < y->timeout)
1749 if (x->timeout > y->timeout)
1755 _public_ int sd_bus_call_async(
1759 sd_bus_message_handler_t callback,
1763 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1764 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1767 assert_return(bus, -EINVAL);
1768 assert_return(m, -EINVAL);
1769 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1770 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1771 assert_return(callback, -EINVAL);
1772 assert_return(!bus_pid_changed(bus), -ECHILD);
1773 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1775 if (!BUS_IS_OPEN(bus->state))
1778 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1782 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1786 r = bus_seal_message(bus, m, usec);
1790 r = bus_remarshal_message(bus, &m);
1794 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1798 s->reply_callback.callback = callback;
1800 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1801 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1803 s->reply_callback.cookie = 0;
1807 s->reply_callback.timeout = calc_elapse(m->timeout);
1808 if (s->reply_callback.timeout != 0) {
1809 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1811 s->reply_callback.timeout = 0;
1816 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1827 int bus_ensure_running(sd_bus *bus) {
1832 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1834 if (bus->state == BUS_RUNNING)
1838 r = sd_bus_process(bus, NULL);
1841 if (bus->state == BUS_RUNNING)
1846 r = sd_bus_wait(bus, (uint64_t) -1);
1852 _public_ int sd_bus_call(
1856 sd_bus_error *error,
1857 sd_bus_message **reply) {
1859 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1865 assert_return(bus, -EINVAL);
1866 assert_return(m, -EINVAL);
1867 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1868 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1869 assert_return(!bus_error_is_dirty(error), -EINVAL);
1870 assert_return(!bus_pid_changed(bus), -ECHILD);
1871 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1873 if (!BUS_IS_OPEN(bus->state))
1876 r = bus_ensure_running(bus);
1880 i = bus->rqueue_size;
1882 r = bus_seal_message(bus, m, usec);
1886 r = bus_remarshal_message(bus, &m);
1890 r = bus_send_internal(bus, m, &cookie, true);
1894 timeout = calc_elapse(m->timeout);
1899 while (i < bus->rqueue_size) {
1900 sd_bus_message *incoming = NULL;
1902 incoming = bus->rqueue[i];
1904 if (incoming->reply_cookie == cookie) {
1905 /* Found a match! */
1907 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1910 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1912 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1916 sd_bus_message_unref(incoming);
1921 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1923 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1924 r = sd_bus_error_copy(error, &incoming->error);
1928 sd_bus_message_unref(incoming);
1931 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1934 streq(bus->unique_name, incoming->sender)) {
1936 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1939 /* Our own message? Somebody is trying
1940 * to send its own client a message,
1941 * let's not dead-lock, let's fail
1944 sd_bus_message_unref(incoming);
1948 /* Try to read more, right-away */
1952 r = bus_read_message(bus, false, 0);
1954 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1955 bus_enter_closing(bus);
1967 n = now(CLOCK_MONOTONIC);
1973 left = (uint64_t) -1;
1975 r = bus_poll(bus, true, left);
1981 r = dispatch_wqueue(bus);
1983 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1984 bus_enter_closing(bus);
1993 _public_ int sd_bus_get_fd(sd_bus *bus) {
1995 assert_return(bus, -EINVAL);
1996 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1997 assert_return(!bus_pid_changed(bus), -ECHILD);
1999 return bus->input_fd;
2002 _public_ int sd_bus_get_events(sd_bus *bus) {
2005 assert_return(bus, -EINVAL);
2006 assert_return(!bus_pid_changed(bus), -ECHILD);
2008 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2011 if (bus->state == BUS_OPENING)
2013 else if (bus->state == BUS_AUTHENTICATING) {
2015 if (bus_socket_auth_needs_write(bus))
2020 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2021 if (bus->rqueue_size <= 0)
2023 if (bus->wqueue_size > 0)
2030 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2031 struct reply_callback *c;
2033 assert_return(bus, -EINVAL);
2034 assert_return(timeout_usec, -EINVAL);
2035 assert_return(!bus_pid_changed(bus), -ECHILD);
2037 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2040 if (bus->track_queue) {
2045 if (bus->state == BUS_CLOSING) {
2050 if (bus->state == BUS_AUTHENTICATING) {
2051 *timeout_usec = bus->auth_timeout;
2055 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2056 *timeout_usec = (uint64_t) -1;
2060 if (bus->rqueue_size > 0) {
2065 c = prioq_peek(bus->reply_callbacks_prioq);
2067 *timeout_usec = (uint64_t) -1;
2071 if (c->timeout == 0) {
2072 *timeout_usec = (uint64_t) -1;
2076 *timeout_usec = c->timeout;
2080 static int process_timeout(sd_bus *bus) {
2081 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2082 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2083 struct reply_callback *c;
2090 c = prioq_peek(bus->reply_callbacks_prioq);
2094 n = now(CLOCK_MONOTONIC);
2098 r = bus_message_new_synthetic_error(
2101 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2106 m->sender = "org.freedesktop.DBus";
2108 r = bus_seal_synthetic_message(bus, m);
2112 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2115 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2118 slot = container_of(c, sd_bus_slot, reply_callback);
2120 bus->iteration_counter ++;
2122 bus->current_message = m;
2123 bus->current_slot = sd_bus_slot_ref(slot);
2124 bus->current_handler = c->callback;
2125 bus->current_userdata = slot->userdata;
2126 r = c->callback(bus, m, slot->userdata, &error_buffer);
2127 bus->current_userdata = NULL;
2128 bus->current_handler = NULL;
2129 bus->current_slot = NULL;
2130 bus->current_message = NULL;
2132 if (slot->floating) {
2133 bus_slot_disconnect(slot);
2134 sd_bus_slot_unref(slot);
2137 sd_bus_slot_unref(slot);
2139 return bus_maybe_reply_error(m, r, &error_buffer);
2142 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2146 if (bus->state != BUS_HELLO)
2149 /* Let's make sure the first message on the bus is the HELLO
2150 * reply. But note that we don't actually parse the message
2151 * here (we leave that to the usual handling), we just verify
2152 * we don't let any earlier msg through. */
2154 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2155 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2158 if (m->reply_cookie != 1)
2164 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2165 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2166 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2167 struct reply_callback *c;
2174 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2175 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2178 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2181 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2184 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2190 slot = container_of(c, sd_bus_slot, reply_callback);
2192 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2194 /* If the reply contained a file descriptor which we
2195 * didn't want we pass an error instead. */
2197 r = bus_message_new_synthetic_error(
2200 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2205 r = bus_seal_synthetic_message(bus, synthetic_reply);
2209 m = synthetic_reply;
2211 r = sd_bus_message_rewind(m, true);
2216 if (c->timeout != 0) {
2217 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2221 bus->current_slot = sd_bus_slot_ref(slot);
2222 bus->current_handler = c->callback;
2223 bus->current_userdata = slot->userdata;
2224 r = c->callback(bus, m, slot->userdata, &error_buffer);
2225 bus->current_userdata = NULL;
2226 bus->current_handler = NULL;
2227 bus->current_slot = NULL;
2229 if (slot->floating) {
2230 bus_slot_disconnect(slot);
2231 sd_bus_slot_unref(slot);
2234 sd_bus_slot_unref(slot);
2236 return bus_maybe_reply_error(m, r, &error_buffer);
2239 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2240 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2241 struct filter_callback *l;
2248 bus->filter_callbacks_modified = false;
2250 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2253 if (bus->filter_callbacks_modified)
2256 /* Don't run this more than once per iteration */
2257 if (l->last_iteration == bus->iteration_counter)
2260 l->last_iteration = bus->iteration_counter;
2262 r = sd_bus_message_rewind(m, true);
2266 slot = container_of(l, sd_bus_slot, filter_callback);
2268 bus->current_slot = sd_bus_slot_ref(slot);
2269 bus->current_handler = l->callback;
2270 bus->current_userdata = slot->userdata;
2271 r = l->callback(bus, m, slot->userdata, &error_buffer);
2272 bus->current_userdata = NULL;
2273 bus->current_handler = NULL;
2274 bus->current_slot = sd_bus_slot_unref(slot);
2276 r = bus_maybe_reply_error(m, r, &error_buffer);
2282 } while (bus->filter_callbacks_modified);
2287 static int process_match(sd_bus *bus, sd_bus_message *m) {
2294 bus->match_callbacks_modified = false;
2296 r = bus_match_run(bus, &bus->match_callbacks, m);
2300 } while (bus->match_callbacks_modified);
2305 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2306 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2312 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2315 if (bus->manual_peer_interface)
2318 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2321 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2324 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2327 if (streq_ptr(m->member, "Ping"))
2328 r = sd_bus_message_new_method_return(m, &reply);
2329 else if (streq_ptr(m->member, "GetMachineId")) {
2333 r = sd_id128_get_machine(&id);
2337 r = sd_bus_message_new_method_return(m, &reply);
2341 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2343 r = sd_bus_message_new_method_errorf(
2345 SD_BUS_ERROR_UNKNOWN_METHOD,
2346 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2352 r = sd_bus_send(bus, reply, NULL);
2359 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2363 /* If we got a message with a file descriptor which we didn't
2364 * want to accept, then let's drop it. How can this even
2365 * happen? For example, when the kernel queues a message into
2366 * an activatable names's queue which allows fds, and then is
2367 * delivered to us later even though we ourselves did not
2370 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2376 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2379 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2380 return 1; /* just eat it up */
2382 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2385 static int process_message(sd_bus *bus, sd_bus_message *m) {
2391 bus->current_message = m;
2392 bus->iteration_counter++;
2394 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2395 bus_message_type_to_string(m->header->type),
2396 strna(sd_bus_message_get_sender(m)),
2397 strna(sd_bus_message_get_destination(m)),
2398 strna(sd_bus_message_get_path(m)),
2399 strna(sd_bus_message_get_interface(m)),
2400 strna(sd_bus_message_get_member(m)),
2401 BUS_MESSAGE_COOKIE(m),
2403 strna(m->error.message));
2405 r = process_hello(bus, m);
2409 r = process_reply(bus, m);
2413 r = process_fd_check(bus, m);
2417 r = process_filter(bus, m);
2421 r = process_match(bus, m);
2425 r = process_builtin(bus, m);
2429 r = bus_process_object(bus, m);
2432 bus->current_message = NULL;
2436 static int dispatch_track(sd_bus *bus) {
2439 if (!bus->track_queue)
2442 bus_track_dispatch(bus->track_queue);
2446 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2447 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2451 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2453 r = process_timeout(bus);
2457 r = dispatch_wqueue(bus);
2461 r = dispatch_track(bus);
2465 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2471 r = process_message(bus, m);
2476 r = sd_bus_message_rewind(m, true);
2485 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2487 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2488 strna(sd_bus_message_get_sender(m)),
2489 strna(sd_bus_message_get_path(m)),
2490 strna(sd_bus_message_get_interface(m)),
2491 strna(sd_bus_message_get_member(m)));
2493 r = sd_bus_reply_method_errorf(
2495 SD_BUS_ERROR_UNKNOWN_OBJECT,
2496 "Unknown object '%s'.", m->path);
2510 static void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m) {
2514 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus.Local";
2515 m->creds.well_known_names_local = true;
2516 m->creds.mask |= (SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_WELL_KNOWN_NAMES) & bus->creds_mask;
2519 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2520 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2521 struct reply_callback *c;
2525 assert(bus->state == BUS_CLOSING);
2527 c = ordered_hashmap_first(bus->reply_callbacks);
2529 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2532 /* First, fail all outstanding method calls */
2533 r = bus_message_new_synthetic_error(
2536 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2541 r = bus_seal_synthetic_message(bus, m);
2545 if (c->timeout != 0) {
2546 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2550 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2553 slot = container_of(c, sd_bus_slot, reply_callback);
2555 bus->iteration_counter++;
2557 bus->current_message = m;
2558 bus->current_slot = sd_bus_slot_ref(slot);
2559 bus->current_handler = c->callback;
2560 bus->current_userdata = slot->userdata;
2561 r = c->callback(bus, m, slot->userdata, &error_buffer);
2562 bus->current_userdata = NULL;
2563 bus->current_handler = NULL;
2564 bus->current_slot = NULL;
2565 bus->current_message = NULL;
2567 if (slot->floating) {
2568 bus_slot_disconnect(slot);
2569 sd_bus_slot_unref(slot);
2572 sd_bus_slot_unref(slot);
2574 return bus_maybe_reply_error(m, r, &error_buffer);
2577 /* Then, synthesize a Disconnected message */
2578 r = sd_bus_message_new_signal(
2581 "/org/freedesktop/DBus/Local",
2582 "org.freedesktop.DBus.Local",
2587 bus_message_set_sender_local(bus, m);
2589 r = bus_seal_synthetic_message(bus, m);
2595 bus->current_message = m;
2596 bus->iteration_counter++;
2598 r = process_filter(bus, m);
2602 r = process_match(bus, m);
2614 bus->current_message = NULL;
2619 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2620 BUS_DONT_DESTROY(bus);
2623 /* Returns 0 when we didn't do anything. This should cause the
2624 * caller to invoke sd_bus_wait() before returning the next
2625 * time. Returns > 0 when we did something, which possibly
2626 * means *ret is filled in with an unprocessed message. */
2628 assert_return(bus, -EINVAL);
2629 assert_return(!bus_pid_changed(bus), -ECHILD);
2631 /* We don't allow recursively invoking sd_bus_process(). */
2632 assert_return(!bus->current_message, -EBUSY);
2633 assert(!bus->current_slot);
2635 switch (bus->state) {
2644 r = bus_socket_process_opening(bus);
2645 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2646 bus_enter_closing(bus);
2654 case BUS_AUTHENTICATING:
2655 r = bus_socket_process_authenticating(bus);
2656 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2657 bus_enter_closing(bus);
2669 r = process_running(bus, hint_priority, priority, ret);
2670 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2671 bus_enter_closing(bus);
2681 return process_closing(bus, ret);
2684 assert_not_reached("Unknown state");
2687 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2688 return bus_process_internal(bus, false, 0, ret);
2691 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2692 return bus_process_internal(bus, true, priority, ret);
2695 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2696 struct pollfd p[2] = {};
2699 usec_t m = USEC_INFINITY;
2703 if (bus->state == BUS_CLOSING)
2706 if (!BUS_IS_OPEN(bus->state))
2709 e = sd_bus_get_events(bus);
2714 /* The caller really needs some more data, he doesn't
2715 * care about what's already read, or any timeouts
2720 /* The caller wants to process if there's something to
2721 * process, but doesn't care otherwise */
2723 r = sd_bus_get_timeout(bus, &until);
2728 nw = now(CLOCK_MONOTONIC);
2729 m = until > nw ? until - nw : 0;
2733 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2736 p[0].fd = bus->input_fd;
2737 if (bus->output_fd == bus->input_fd) {
2741 p[0].events = e & POLLIN;
2742 p[1].fd = bus->output_fd;
2743 p[1].events = e & POLLOUT;
2747 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2751 return r > 0 ? 1 : 0;
2754 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2756 assert_return(bus, -EINVAL);
2757 assert_return(!bus_pid_changed(bus), -ECHILD);
2759 if (bus->state == BUS_CLOSING)
2762 if (!BUS_IS_OPEN(bus->state))
2765 if (bus->rqueue_size > 0)
2768 return bus_poll(bus, false, timeout_usec);
2771 _public_ int sd_bus_flush(sd_bus *bus) {
2774 assert_return(bus, -EINVAL);
2775 assert_return(!bus_pid_changed(bus), -ECHILD);
2777 if (bus->state == BUS_CLOSING)
2780 if (!BUS_IS_OPEN(bus->state))
2783 r = bus_ensure_running(bus);
2787 if (bus->wqueue_size <= 0)
2791 r = dispatch_wqueue(bus);
2793 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2794 bus_enter_closing(bus);
2801 if (bus->wqueue_size <= 0)
2804 r = bus_poll(bus, false, (uint64_t) -1);
2810 _public_ int sd_bus_add_filter(
2813 sd_bus_message_handler_t callback,
2818 assert_return(bus, -EINVAL);
2819 assert_return(callback, -EINVAL);
2820 assert_return(!bus_pid_changed(bus), -ECHILD);
2822 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2826 s->filter_callback.callback = callback;
2828 bus->filter_callbacks_modified = true;
2829 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2837 _public_ int sd_bus_add_match(
2841 sd_bus_message_handler_t callback,
2844 struct bus_match_component *components = NULL;
2845 unsigned n_components = 0;
2846 sd_bus_slot *s = NULL;
2849 assert_return(bus, -EINVAL);
2850 assert_return(match, -EINVAL);
2851 assert_return(!bus_pid_changed(bus), -ECHILD);
2853 r = bus_match_parse(match, &components, &n_components);
2857 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2863 s->match_callback.callback = callback;
2864 s->match_callback.cookie = ++bus->match_cookie;
2866 if (bus->bus_client) {
2868 if (!bus->is_kernel) {
2869 /* When this is not a kernel transport, we
2870 * store the original match string, so that we
2871 * can use it to remove the match again */
2873 s->match_callback.match_string = strdup(match);
2874 if (!s->match_callback.match_string) {
2880 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2885 bus->match_callbacks_modified = true;
2886 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2895 bus_match_parse_free(components, n_components);
2896 sd_bus_slot_unref(s);
2901 int bus_remove_match_by_string(
2904 sd_bus_message_handler_t callback,
2907 struct bus_match_component *components = NULL;
2908 unsigned n_components = 0;
2909 struct match_callback *c;
2912 assert_return(bus, -EINVAL);
2913 assert_return(match, -EINVAL);
2914 assert_return(!bus_pid_changed(bus), -ECHILD);
2916 r = bus_match_parse(match, &components, &n_components);
2920 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2924 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2927 bus_match_parse_free(components, n_components);
2932 bool bus_pid_changed(sd_bus *bus) {
2935 /* We don't support people creating a bus connection and
2936 * keeping it around over a fork(). Let's complain. */
2938 return bus->original_pid != getpid();
2941 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2942 sd_bus *bus = userdata;
2947 r = sd_bus_process(bus, NULL);
2954 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2955 sd_bus *bus = userdata;
2960 r = sd_bus_process(bus, NULL);
2967 static int prepare_callback(sd_event_source *s, void *userdata) {
2968 sd_bus *bus = userdata;
2975 e = sd_bus_get_events(bus);
2979 if (bus->output_fd != bus->input_fd) {
2981 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2985 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2989 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2994 r = sd_bus_get_timeout(bus, &until);
3000 j = sd_event_source_set_time(bus->time_event_source, until);
3005 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3012 static int quit_callback(sd_event_source *event, void *userdata) {
3013 sd_bus *bus = userdata;
3023 static int attach_io_events(sd_bus *bus) {
3028 if (bus->input_fd < 0)
3034 if (!bus->input_io_event_source) {
3035 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3039 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3043 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3047 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3049 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3054 if (bus->output_fd != bus->input_fd) {
3055 assert(bus->output_fd >= 0);
3057 if (!bus->output_io_event_source) {
3058 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3062 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3066 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3068 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3077 static void detach_io_events(sd_bus *bus) {
3080 if (bus->input_io_event_source) {
3081 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3082 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3085 if (bus->output_io_event_source) {
3086 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3087 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3091 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3094 assert_return(bus, -EINVAL);
3095 assert_return(!bus->event, -EBUSY);
3097 assert(!bus->input_io_event_source);
3098 assert(!bus->output_io_event_source);
3099 assert(!bus->time_event_source);
3102 bus->event = sd_event_ref(event);
3104 r = sd_event_default(&bus->event);
3109 bus->event_priority = priority;
3111 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3115 r = sd_event_source_set_priority(bus->time_event_source, priority);
3119 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3123 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3127 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3131 r = attach_io_events(bus);
3138 sd_bus_detach_event(bus);
3142 _public_ int sd_bus_detach_event(sd_bus *bus) {
3143 assert_return(bus, -EINVAL);
3148 detach_io_events(bus);
3150 if (bus->time_event_source) {
3151 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3152 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3155 if (bus->quit_event_source) {
3156 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3157 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3160 bus->event = sd_event_unref(bus->event);
3164 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3165 assert_return(bus, NULL);
3170 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3171 assert_return(bus, NULL);
3173 return bus->current_message;
3176 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3177 assert_return(bus, NULL);
3179 return bus->current_slot;
3182 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3183 assert_return(bus, NULL);
3185 return bus->current_handler;
3188 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3189 assert_return(bus, NULL);
3191 return bus->current_userdata;
3194 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3199 assert(default_bus);
3202 return !!*default_bus;
3205 *ret = sd_bus_ref(*default_bus);
3213 b->default_bus_ptr = default_bus;
3221 _public_ int sd_bus_default_system(sd_bus **ret) {
3222 static thread_local sd_bus *default_system_bus = NULL;
3224 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3227 _public_ int sd_bus_default_user(sd_bus **ret) {
3228 static thread_local sd_bus *default_user_bus = NULL;
3230 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3233 _public_ int sd_bus_default(sd_bus **ret) {
3237 /* Let's try our best to reuse another cached connection. If
3238 * the starter bus type is set, connect via our normal
3239 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3240 * we can share the connection with the user/system default
3243 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3245 if (streq(e, "system"))
3246 return sd_bus_default_system(ret);
3247 else if (STR_IN_SET(e, "user", "session"))
3248 return sd_bus_default_user(ret);
3251 /* No type is specified, so we have not other option than to
3252 * use the starter address if it is set. */
3254 e = secure_getenv("DBUS_STARTER_ADDRESS");
3256 static thread_local sd_bus *default_starter_bus = NULL;
3258 return bus_default(sd_bus_open, &default_starter_bus, ret);
3261 /* Finally, if nothing is set use the cached connection for
3262 * the right scope */
3264 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3265 return sd_bus_default_user(ret);
3267 return sd_bus_default_system(ret);
3270 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3271 assert_return(b, -EINVAL);
3272 assert_return(tid, -EINVAL);
3273 assert_return(!bus_pid_changed(b), -ECHILD);
3281 return sd_event_get_tid(b->event, tid);
3286 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3287 _cleanup_free_ char *e = NULL;
3290 assert_return(object_path_is_valid(prefix), -EINVAL);
3291 assert_return(external_id, -EINVAL);
3292 assert_return(ret_path, -EINVAL);
3294 e = bus_label_escape(external_id);
3298 ret = strjoin(prefix, "/", e, NULL);
3306 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3310 assert_return(object_path_is_valid(path), -EINVAL);
3311 assert_return(object_path_is_valid(prefix), -EINVAL);
3312 assert_return(external_id, -EINVAL);
3314 e = object_path_startswith(path, prefix);
3316 *external_id = NULL;
3320 ret = bus_label_unescape(e);
3328 _public_ int sd_bus_try_close(sd_bus *bus) {
3331 assert_return(bus, -EINVAL);
3332 assert_return(!bus_pid_changed(bus), -ECHILD);
3334 if (!bus->is_kernel)
3337 if (!BUS_IS_OPEN(bus->state))
3340 if (bus->rqueue_size > 0)
3343 if (bus->wqueue_size > 0)
3346 r = bus_kernel_try_close(bus);
3354 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3355 assert_return(bus, -EINVAL);
3356 assert_return(description, -EINVAL);
3357 assert_return(bus->description, -ENXIO);
3358 assert_return(!bus_pid_changed(bus), -ECHILD);
3360 *description = bus->description;
3364 int bus_get_root_path(sd_bus *bus) {
3367 if (bus->cgroup_root)
3370 r = cg_get_root_path(&bus->cgroup_root);
3372 bus->cgroup_root = strdup("/");
3373 if (!bus->cgroup_root)
3382 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3385 assert_return(bus, -EINVAL);
3386 assert_return(scope, -EINVAL);
3387 assert_return(!bus_pid_changed(bus), -ECHILD);
3389 if (bus->is_kernel) {
3390 _cleanup_free_ char *n = NULL;
3393 r = bus_kernel_get_bus_name(bus, &n);
3397 if (streq(n, "0-system")) {
3402 dash = strchr(n, '-');
3403 if (streq_ptr(dash, "-user")) {
3414 if (bus->is_system) {
3422 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3424 assert_return(bus, -EINVAL);
3425 assert_return(address, -EINVAL);
3426 assert_return(!bus_pid_changed(bus), -ECHILD);
3429 *address = bus->address;
3436 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3437 assert_return(bus, -EINVAL);
3438 assert_return(mask, -EINVAL);
3439 assert_return(!bus_pid_changed(bus), -ECHILD);
3441 *mask = bus->creds_mask;
3445 int sd_bus_is_bus_client(sd_bus *bus) {
3446 assert_return(bus, -EINVAL);
3447 assert_return(!bus_pid_changed(bus), -ECHILD);
3449 return bus->bus_client;
3452 int sd_bus_is_server(sd_bus *bus) {
3453 assert_return(bus, -EINVAL);
3454 assert_return(!bus_pid_changed(bus), -ECHILD);
3456 return bus->is_server;
3459 int sd_bus_is_anonymous(sd_bus *bus) {
3460 assert_return(bus, -EINVAL);
3461 assert_return(!bus_pid_changed(bus), -ECHILD);
3463 return bus->anonymous_auth;
3466 int sd_bus_is_trusted(sd_bus *bus) {
3467 assert_return(bus, -EINVAL);
3468 assert_return(!bus_pid_changed(bus), -ECHILD);
3470 return bus->trusted;
3473 int sd_bus_is_monitor(sd_bus *bus) {
3474 assert_return(bus, -EINVAL);
3475 assert_return(!bus_pid_changed(bus), -ECHILD);
3477 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);