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 | KDBUS_ATTACH_PIDS;
1101 r = sd_bus_start(b);
1113 int bus_set_address_system(sd_bus *b) {
1117 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1119 return sd_bus_set_address(b, e);
1121 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1124 _public_ int sd_bus_open_system(sd_bus **ret) {
1128 assert_return(ret, -EINVAL);
1134 r = bus_set_address_system(b);
1138 b->bus_client = true;
1139 b->is_system = true;
1141 /* Let's do per-method access control on the system bus. We
1142 * need the caller's UID and capability set for that. */
1144 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1146 r = sd_bus_start(b);
1158 int bus_set_address_user(sd_bus *b) {
1163 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1165 return sd_bus_set_address(b, e);
1167 e = secure_getenv("XDG_RUNTIME_DIR");
1169 _cleanup_free_ char *ee = NULL;
1171 ee = bus_address_escape(e);
1176 (void) asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, getuid(), ee);
1178 (void) asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1182 (void) asprintf(&b->address, KERNEL_USER_BUS_FMT, getuid());
1184 return -ECONNREFUSED;
1194 _public_ int sd_bus_open_user(sd_bus **ret) {
1198 assert_return(ret, -EINVAL);
1204 r = bus_set_address_user(b);
1208 b->bus_client = true;
1211 /* We don't do any per-method access control on the user
1215 r = sd_bus_start(b);
1227 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1228 _cleanup_free_ char *e = NULL;
1229 char *m = NULL, *c = NULL;
1234 /* Let's see if we shall enter some container */
1235 m = strchr(host, ':');
1239 /* Let's make sure this is not a port of some kind,
1240 * and is a valid machine name. */
1241 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1244 /* Cut out the host part */
1245 t = strndupa(host, m - host - 1);
1246 e = bus_address_escape(t);
1250 c = strappenda(",argv4=--machine=", m);
1255 e = bus_address_escape(host);
1260 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1267 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1271 assert_return(host, -EINVAL);
1272 assert_return(ret, -EINVAL);
1274 r = sd_bus_new(&bus);
1278 r = bus_set_address_system_remote(bus, host);
1282 bus->bus_client = true;
1283 bus->trusted = false;
1285 r = sd_bus_start(bus);
1297 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1298 _cleanup_free_ char *e = NULL;
1303 e = bus_address_escape(machine);
1308 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1310 b->address = strjoin("x-container-unix:machine=", e, NULL);
1318 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1322 assert_return(machine, -EINVAL);
1323 assert_return(ret, -EINVAL);
1324 assert_return(machine_name_is_valid(machine), -EINVAL);
1326 r = sd_bus_new(&bus);
1330 r = bus_set_address_system_container(bus, machine);
1334 bus->bus_client = true;
1335 bus->trusted = false;
1337 r = sd_bus_start(bus);
1349 _public_ void sd_bus_close(sd_bus *bus) {
1353 if (bus->state == BUS_CLOSED)
1355 if (bus_pid_changed(bus))
1358 bus->state = BUS_CLOSED;
1360 sd_bus_detach_event(bus);
1362 /* Drop all queued messages so that they drop references to
1363 * the bus object and the bus may be freed */
1364 bus_reset_queues(bus);
1366 if (!bus->is_kernel)
1369 /* We'll leave the fd open in case this is a kernel bus, since
1370 * there might still be memblocks around that reference this
1371 * bus, and they might need to invoke the KDBUS_CMD_FREE
1372 * ioctl on the fd when they are freed. */
1375 static void bus_enter_closing(sd_bus *bus) {
1378 if (bus->state != BUS_OPENING &&
1379 bus->state != BUS_AUTHENTICATING &&
1380 bus->state != BUS_HELLO &&
1381 bus->state != BUS_RUNNING)
1384 bus->state = BUS_CLOSING;
1387 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1388 assert_return(bus, NULL);
1390 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1395 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1401 i = REFCNT_DEC(bus->n_ref);
1409 _public_ int sd_bus_is_open(sd_bus *bus) {
1411 assert_return(bus, -EINVAL);
1412 assert_return(!bus_pid_changed(bus), -ECHILD);
1414 return BUS_IS_OPEN(bus->state);
1417 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1420 assert_return(bus, -EINVAL);
1421 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1422 assert_return(!bus_pid_changed(bus), -ECHILD);
1424 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1427 if (type == SD_BUS_TYPE_UNIX_FD) {
1428 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1431 r = bus_ensure_running(bus);
1435 return bus->can_fds;
1438 return bus_type_is_valid(type);
1441 _public_ int sd_bus_get_owner_id(sd_bus *bus, sd_id128_t *id) {
1444 assert_return(bus, -EINVAL);
1445 assert_return(id, -EINVAL);
1446 assert_return(!bus_pid_changed(bus), -ECHILD);
1448 r = bus_ensure_running(bus);
1452 *id = bus->server_id;
1456 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1461 /* If we copy the same message to multiple
1462 * destinations, avoid using the same cookie
1464 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1469 timeout = BUS_DEFAULT_TIMEOUT;
1471 return bus_message_seal(m, ++b->cookie, timeout);
1474 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1477 /* Do packet version and endianness already match? */
1478 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1479 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1482 /* No? Then remarshal! */
1483 return bus_message_remarshal(b, m);
1486 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1490 /* The bus specification says the serial number cannot be 0,
1491 * hence let's fill something in for synthetic messages. Since
1492 * synthetic messages might have a fake sender and we don't
1493 * want to interfere with the real sender's serial numbers we
1494 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1495 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1496 * even though kdbus can do 64bit. */
1498 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1501 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1508 r = bus_kernel_write_message(bus, m, hint_sync_call);
1510 r = bus_socket_write_message(bus, m, idx);
1515 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1516 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1517 bus_message_type_to_string(m->header->type),
1518 strna(sd_bus_message_get_sender(m)),
1519 strna(sd_bus_message_get_destination(m)),
1520 strna(sd_bus_message_get_path(m)),
1521 strna(sd_bus_message_get_interface(m)),
1522 strna(sd_bus_message_get_member(m)),
1523 BUS_MESSAGE_COOKIE(m),
1525 strna(m->error.message));
1530 static int dispatch_wqueue(sd_bus *bus) {
1534 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1536 while (bus->wqueue_size > 0) {
1538 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1542 /* Didn't do anything this time */
1544 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1545 /* Fully written. Let's drop the entry from
1548 * This isn't particularly optimized, but
1549 * well, this is supposed to be our worst-case
1550 * buffer only, and the socket buffer is
1551 * supposed to be our primary buffer, and if
1552 * it got full, then all bets are off
1555 bus->wqueue_size --;
1556 sd_bus_message_unref(bus->wqueue[0]);
1557 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1567 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1571 return bus_kernel_read_message(bus, hint_priority, priority);
1573 return bus_socket_read_message(bus);
1576 int bus_rqueue_make_room(sd_bus *bus) {
1579 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1582 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1588 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1593 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1595 /* Note that the priority logic is only available on kdbus,
1596 * where the rqueue is unused. We check the rqueue here
1597 * anyway, because it's simple... */
1600 if (bus->rqueue_size > 0) {
1601 /* Dispatch a queued message */
1603 *m = bus->rqueue[0];
1604 bus->rqueue_size --;
1605 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1609 /* Try to read a new message */
1610 r = bus_read_message(bus, hint_priority, priority);
1620 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1621 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1624 assert_return(bus, -EINVAL);
1625 assert_return(m, -EINVAL);
1626 assert_return(!bus_pid_changed(bus), -ECHILD);
1627 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1629 if (!BUS_IS_OPEN(bus->state))
1633 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1640 /* If the cookie number isn't kept, then we know that no reply
1642 if (!cookie && !m->sealed)
1643 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1645 r = bus_seal_message(bus, m, 0);
1649 /* Remarshall if we have to. This will possibly unref the
1650 * message and place a replacement in m */
1651 r = bus_remarshal_message(bus, &m);
1655 /* If this is a reply and no reply was requested, then let's
1656 * suppress this, if we can */
1657 if (m->dont_send && !cookie)
1660 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1663 r = bus_write_message(bus, m, hint_sync_call, &idx);
1665 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1666 bus_enter_closing(bus);
1671 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1672 /* Wasn't fully written. So let's remember how
1673 * much was written. Note that the first entry
1674 * of the wqueue array is always allocated so
1675 * that we always can remember how much was
1677 bus->wqueue[0] = sd_bus_message_ref(m);
1678 bus->wqueue_size = 1;
1682 /* Just append it to the queue. */
1684 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1687 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1690 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1694 *cookie = BUS_MESSAGE_COOKIE(m);
1699 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1700 return bus_send_internal(bus, m, cookie, false);
1703 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1706 assert_return(bus, -EINVAL);
1707 assert_return(m, -EINVAL);
1708 assert_return(!bus_pid_changed(bus), -ECHILD);
1710 if (!BUS_IS_OPEN(bus->state))
1713 if (!streq_ptr(m->destination, destination)) {
1718 r = sd_bus_message_set_destination(m, destination);
1723 return sd_bus_send(bus, m, cookie);
1726 static usec_t calc_elapse(uint64_t usec) {
1727 if (usec == (uint64_t) -1)
1730 return now(CLOCK_MONOTONIC) + usec;
1733 static int timeout_compare(const void *a, const void *b) {
1734 const struct reply_callback *x = a, *y = b;
1736 if (x->timeout != 0 && y->timeout == 0)
1739 if (x->timeout == 0 && y->timeout != 0)
1742 if (x->timeout < y->timeout)
1745 if (x->timeout > y->timeout)
1751 _public_ int sd_bus_call_async(
1755 sd_bus_message_handler_t callback,
1759 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1760 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1763 assert_return(bus, -EINVAL);
1764 assert_return(m, -EINVAL);
1765 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1766 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1767 assert_return(callback, -EINVAL);
1768 assert_return(!bus_pid_changed(bus), -ECHILD);
1769 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1771 if (!BUS_IS_OPEN(bus->state))
1774 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1778 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1782 r = bus_seal_message(bus, m, usec);
1786 r = bus_remarshal_message(bus, &m);
1790 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1794 s->reply_callback.callback = callback;
1796 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1797 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1799 s->reply_callback.cookie = 0;
1803 s->reply_callback.timeout = calc_elapse(m->timeout);
1804 if (s->reply_callback.timeout != 0) {
1805 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1807 s->reply_callback.timeout = 0;
1812 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1823 int bus_ensure_running(sd_bus *bus) {
1828 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1830 if (bus->state == BUS_RUNNING)
1834 r = sd_bus_process(bus, NULL);
1837 if (bus->state == BUS_RUNNING)
1842 r = sd_bus_wait(bus, (uint64_t) -1);
1848 _public_ int sd_bus_call(
1852 sd_bus_error *error,
1853 sd_bus_message **reply) {
1855 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1861 assert_return(bus, -EINVAL);
1862 assert_return(m, -EINVAL);
1863 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1864 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1865 assert_return(!bus_error_is_dirty(error), -EINVAL);
1866 assert_return(!bus_pid_changed(bus), -ECHILD);
1867 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1869 if (!BUS_IS_OPEN(bus->state))
1872 r = bus_ensure_running(bus);
1876 i = bus->rqueue_size;
1878 r = bus_seal_message(bus, m, usec);
1882 r = bus_remarshal_message(bus, &m);
1886 r = bus_send_internal(bus, m, &cookie, true);
1890 timeout = calc_elapse(m->timeout);
1895 while (i < bus->rqueue_size) {
1896 sd_bus_message *incoming = NULL;
1898 incoming = bus->rqueue[i];
1900 if (incoming->reply_cookie == cookie) {
1901 /* Found a match! */
1903 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1906 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1908 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1912 sd_bus_message_unref(incoming);
1917 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1919 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1920 r = sd_bus_error_copy(error, &incoming->error);
1924 sd_bus_message_unref(incoming);
1927 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1930 streq(bus->unique_name, incoming->sender)) {
1932 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1935 /* Our own message? Somebody is trying
1936 * to send its own client a message,
1937 * let's not dead-lock, let's fail
1940 sd_bus_message_unref(incoming);
1944 /* Try to read more, right-away */
1948 r = bus_read_message(bus, false, 0);
1950 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1951 bus_enter_closing(bus);
1963 n = now(CLOCK_MONOTONIC);
1969 left = (uint64_t) -1;
1971 r = bus_poll(bus, true, left);
1977 r = dispatch_wqueue(bus);
1979 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1980 bus_enter_closing(bus);
1989 _public_ int sd_bus_get_fd(sd_bus *bus) {
1991 assert_return(bus, -EINVAL);
1992 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1993 assert_return(!bus_pid_changed(bus), -ECHILD);
1995 return bus->input_fd;
1998 _public_ int sd_bus_get_events(sd_bus *bus) {
2001 assert_return(bus, -EINVAL);
2002 assert_return(!bus_pid_changed(bus), -ECHILD);
2004 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2007 if (bus->state == BUS_OPENING)
2009 else if (bus->state == BUS_AUTHENTICATING) {
2011 if (bus_socket_auth_needs_write(bus))
2016 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2017 if (bus->rqueue_size <= 0)
2019 if (bus->wqueue_size > 0)
2026 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2027 struct reply_callback *c;
2029 assert_return(bus, -EINVAL);
2030 assert_return(timeout_usec, -EINVAL);
2031 assert_return(!bus_pid_changed(bus), -ECHILD);
2033 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2036 if (bus->track_queue) {
2041 if (bus->state == BUS_CLOSING) {
2046 if (bus->state == BUS_AUTHENTICATING) {
2047 *timeout_usec = bus->auth_timeout;
2051 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2052 *timeout_usec = (uint64_t) -1;
2056 if (bus->rqueue_size > 0) {
2061 c = prioq_peek(bus->reply_callbacks_prioq);
2063 *timeout_usec = (uint64_t) -1;
2067 if (c->timeout == 0) {
2068 *timeout_usec = (uint64_t) -1;
2072 *timeout_usec = c->timeout;
2076 static int process_timeout(sd_bus *bus) {
2077 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2078 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2079 struct reply_callback *c;
2086 c = prioq_peek(bus->reply_callbacks_prioq);
2090 n = now(CLOCK_MONOTONIC);
2094 r = bus_message_new_synthetic_error(
2097 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2102 m->sender = "org.freedesktop.DBus";
2104 r = bus_seal_synthetic_message(bus, m);
2108 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2111 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2114 slot = container_of(c, sd_bus_slot, reply_callback);
2116 bus->iteration_counter ++;
2118 bus->current_message = m;
2119 bus->current_slot = sd_bus_slot_ref(slot);
2120 bus->current_handler = c->callback;
2121 bus->current_userdata = slot->userdata;
2122 r = c->callback(bus, m, slot->userdata, &error_buffer);
2123 bus->current_userdata = NULL;
2124 bus->current_handler = NULL;
2125 bus->current_slot = NULL;
2126 bus->current_message = NULL;
2128 if (slot->floating) {
2129 bus_slot_disconnect(slot);
2130 sd_bus_slot_unref(slot);
2133 sd_bus_slot_unref(slot);
2135 return bus_maybe_reply_error(m, r, &error_buffer);
2138 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2142 if (bus->state != BUS_HELLO)
2145 /* Let's make sure the first message on the bus is the HELLO
2146 * reply. But note that we don't actually parse the message
2147 * here (we leave that to the usual handling), we just verify
2148 * we don't let any earlier msg through. */
2150 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2151 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2154 if (m->reply_cookie != 1)
2160 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2161 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2162 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2163 struct reply_callback *c;
2170 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2171 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2174 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2177 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2180 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2186 slot = container_of(c, sd_bus_slot, reply_callback);
2188 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2190 /* If the reply contained a file descriptor which we
2191 * didn't want we pass an error instead. */
2193 r = bus_message_new_synthetic_error(
2196 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2201 r = bus_seal_synthetic_message(bus, synthetic_reply);
2205 m = synthetic_reply;
2207 r = sd_bus_message_rewind(m, true);
2212 if (c->timeout != 0) {
2213 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2217 bus->current_slot = sd_bus_slot_ref(slot);
2218 bus->current_handler = c->callback;
2219 bus->current_userdata = slot->userdata;
2220 r = c->callback(bus, m, slot->userdata, &error_buffer);
2221 bus->current_userdata = NULL;
2222 bus->current_handler = NULL;
2223 bus->current_slot = NULL;
2225 if (slot->floating) {
2226 bus_slot_disconnect(slot);
2227 sd_bus_slot_unref(slot);
2230 sd_bus_slot_unref(slot);
2232 return bus_maybe_reply_error(m, r, &error_buffer);
2235 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2236 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2237 struct filter_callback *l;
2244 bus->filter_callbacks_modified = false;
2246 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2249 if (bus->filter_callbacks_modified)
2252 /* Don't run this more than once per iteration */
2253 if (l->last_iteration == bus->iteration_counter)
2256 l->last_iteration = bus->iteration_counter;
2258 r = sd_bus_message_rewind(m, true);
2262 slot = container_of(l, sd_bus_slot, filter_callback);
2264 bus->current_slot = sd_bus_slot_ref(slot);
2265 bus->current_handler = l->callback;
2266 bus->current_userdata = slot->userdata;
2267 r = l->callback(bus, m, slot->userdata, &error_buffer);
2268 bus->current_userdata = NULL;
2269 bus->current_handler = NULL;
2270 bus->current_slot = sd_bus_slot_unref(slot);
2272 r = bus_maybe_reply_error(m, r, &error_buffer);
2278 } while (bus->filter_callbacks_modified);
2283 static int process_match(sd_bus *bus, sd_bus_message *m) {
2290 bus->match_callbacks_modified = false;
2292 r = bus_match_run(bus, &bus->match_callbacks, m);
2296 } while (bus->match_callbacks_modified);
2301 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2302 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2308 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2311 if (bus->manual_peer_interface)
2314 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2317 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2320 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2323 if (streq_ptr(m->member, "Ping"))
2324 r = sd_bus_message_new_method_return(m, &reply);
2325 else if (streq_ptr(m->member, "GetMachineId")) {
2329 r = sd_id128_get_machine(&id);
2333 r = sd_bus_message_new_method_return(m, &reply);
2337 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2339 r = sd_bus_message_new_method_errorf(
2341 SD_BUS_ERROR_UNKNOWN_METHOD,
2342 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2348 r = sd_bus_send(bus, reply, NULL);
2355 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2359 /* If we got a message with a file descriptor which we didn't
2360 * want to accept, then let's drop it. How can this even
2361 * happen? For example, when the kernel queues a message into
2362 * an activatable names's queue which allows fds, and then is
2363 * delivered to us later even though we ourselves did not
2366 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2372 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2375 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2376 return 1; /* just eat it up */
2378 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2381 static int process_message(sd_bus *bus, sd_bus_message *m) {
2387 bus->current_message = m;
2388 bus->iteration_counter++;
2390 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2391 bus_message_type_to_string(m->header->type),
2392 strna(sd_bus_message_get_sender(m)),
2393 strna(sd_bus_message_get_destination(m)),
2394 strna(sd_bus_message_get_path(m)),
2395 strna(sd_bus_message_get_interface(m)),
2396 strna(sd_bus_message_get_member(m)),
2397 BUS_MESSAGE_COOKIE(m),
2399 strna(m->error.message));
2401 r = process_hello(bus, m);
2405 r = process_reply(bus, m);
2409 r = process_fd_check(bus, m);
2413 r = process_filter(bus, m);
2417 r = process_match(bus, m);
2421 r = process_builtin(bus, m);
2425 r = bus_process_object(bus, m);
2428 bus->current_message = NULL;
2432 static int dispatch_track(sd_bus *bus) {
2435 if (!bus->track_queue)
2438 bus_track_dispatch(bus->track_queue);
2442 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2443 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2447 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2449 r = process_timeout(bus);
2453 r = dispatch_wqueue(bus);
2457 r = dispatch_track(bus);
2461 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2467 r = process_message(bus, m);
2472 r = sd_bus_message_rewind(m, true);
2481 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2483 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2484 strna(sd_bus_message_get_sender(m)),
2485 strna(sd_bus_message_get_path(m)),
2486 strna(sd_bus_message_get_interface(m)),
2487 strna(sd_bus_message_get_member(m)));
2489 r = sd_bus_reply_method_errorf(
2491 SD_BUS_ERROR_UNKNOWN_OBJECT,
2492 "Unknown object '%s'.", m->path);
2506 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2507 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2508 struct reply_callback *c;
2512 assert(bus->state == BUS_CLOSING);
2514 c = ordered_hashmap_first(bus->reply_callbacks);
2516 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2519 /* First, fail all outstanding method calls */
2520 r = bus_message_new_synthetic_error(
2523 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2528 r = bus_seal_synthetic_message(bus, m);
2532 if (c->timeout != 0) {
2533 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2537 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2540 slot = container_of(c, sd_bus_slot, reply_callback);
2542 bus->iteration_counter++;
2544 bus->current_message = m;
2545 bus->current_slot = sd_bus_slot_ref(slot);
2546 bus->current_handler = c->callback;
2547 bus->current_userdata = slot->userdata;
2548 r = c->callback(bus, m, slot->userdata, &error_buffer);
2549 bus->current_userdata = NULL;
2550 bus->current_handler = NULL;
2551 bus->current_slot = NULL;
2552 bus->current_message = NULL;
2554 if (slot->floating) {
2555 bus_slot_disconnect(slot);
2556 sd_bus_slot_unref(slot);
2559 sd_bus_slot_unref(slot);
2561 return bus_maybe_reply_error(m, r, &error_buffer);
2564 /* Then, synthesize a Disconnected message */
2565 r = sd_bus_message_new_signal(
2568 "/org/freedesktop/DBus/Local",
2569 "org.freedesktop.DBus.Local",
2574 m->sender = "org.freedesktop.DBus.Local";
2576 r = bus_seal_synthetic_message(bus, m);
2582 bus->current_message = m;
2583 bus->iteration_counter++;
2585 r = process_filter(bus, m);
2589 r = process_match(bus, m);
2601 bus->current_message = NULL;
2606 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2607 BUS_DONT_DESTROY(bus);
2610 /* Returns 0 when we didn't do anything. This should cause the
2611 * caller to invoke sd_bus_wait() before returning the next
2612 * time. Returns > 0 when we did something, which possibly
2613 * means *ret is filled in with an unprocessed message. */
2615 assert_return(bus, -EINVAL);
2616 assert_return(!bus_pid_changed(bus), -ECHILD);
2618 /* We don't allow recursively invoking sd_bus_process(). */
2619 assert_return(!bus->current_message, -EBUSY);
2620 assert(!bus->current_slot);
2622 switch (bus->state) {
2631 r = bus_socket_process_opening(bus);
2632 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2633 bus_enter_closing(bus);
2641 case BUS_AUTHENTICATING:
2642 r = bus_socket_process_authenticating(bus);
2643 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2644 bus_enter_closing(bus);
2656 r = process_running(bus, hint_priority, priority, ret);
2657 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2658 bus_enter_closing(bus);
2668 return process_closing(bus, ret);
2671 assert_not_reached("Unknown state");
2674 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2675 return bus_process_internal(bus, false, 0, ret);
2678 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2679 return bus_process_internal(bus, true, priority, ret);
2682 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2683 struct pollfd p[2] = {};
2686 usec_t m = USEC_INFINITY;
2690 if (bus->state == BUS_CLOSING)
2693 if (!BUS_IS_OPEN(bus->state))
2696 e = sd_bus_get_events(bus);
2701 /* The caller really needs some more data, he doesn't
2702 * care about what's already read, or any timeouts
2707 /* The caller wants to process if there's something to
2708 * process, but doesn't care otherwise */
2710 r = sd_bus_get_timeout(bus, &until);
2715 nw = now(CLOCK_MONOTONIC);
2716 m = until > nw ? until - nw : 0;
2720 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2723 p[0].fd = bus->input_fd;
2724 if (bus->output_fd == bus->input_fd) {
2728 p[0].events = e & POLLIN;
2729 p[1].fd = bus->output_fd;
2730 p[1].events = e & POLLOUT;
2734 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2738 return r > 0 ? 1 : 0;
2741 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2743 assert_return(bus, -EINVAL);
2744 assert_return(!bus_pid_changed(bus), -ECHILD);
2746 if (bus->state == BUS_CLOSING)
2749 if (!BUS_IS_OPEN(bus->state))
2752 if (bus->rqueue_size > 0)
2755 return bus_poll(bus, false, timeout_usec);
2758 _public_ int sd_bus_flush(sd_bus *bus) {
2761 assert_return(bus, -EINVAL);
2762 assert_return(!bus_pid_changed(bus), -ECHILD);
2764 if (bus->state == BUS_CLOSING)
2767 if (!BUS_IS_OPEN(bus->state))
2770 r = bus_ensure_running(bus);
2774 if (bus->wqueue_size <= 0)
2778 r = dispatch_wqueue(bus);
2780 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2781 bus_enter_closing(bus);
2788 if (bus->wqueue_size <= 0)
2791 r = bus_poll(bus, false, (uint64_t) -1);
2797 _public_ int sd_bus_add_filter(
2800 sd_bus_message_handler_t callback,
2805 assert_return(bus, -EINVAL);
2806 assert_return(callback, -EINVAL);
2807 assert_return(!bus_pid_changed(bus), -ECHILD);
2809 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2813 s->filter_callback.callback = callback;
2815 bus->filter_callbacks_modified = true;
2816 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2824 _public_ int sd_bus_add_match(
2828 sd_bus_message_handler_t callback,
2831 struct bus_match_component *components = NULL;
2832 unsigned n_components = 0;
2833 sd_bus_slot *s = NULL;
2836 assert_return(bus, -EINVAL);
2837 assert_return(match, -EINVAL);
2838 assert_return(!bus_pid_changed(bus), -ECHILD);
2840 r = bus_match_parse(match, &components, &n_components);
2844 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2850 s->match_callback.callback = callback;
2851 s->match_callback.cookie = ++bus->match_cookie;
2853 if (bus->bus_client) {
2855 if (!bus->is_kernel) {
2856 /* When this is not a kernel transport, we
2857 * store the original match string, so that we
2858 * can use it to remove the match again */
2860 s->match_callback.match_string = strdup(match);
2861 if (!s->match_callback.match_string) {
2867 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2872 bus->match_callbacks_modified = true;
2873 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2882 bus_match_parse_free(components, n_components);
2883 sd_bus_slot_unref(s);
2888 int bus_remove_match_by_string(
2891 sd_bus_message_handler_t callback,
2894 struct bus_match_component *components = NULL;
2895 unsigned n_components = 0;
2896 struct match_callback *c;
2899 assert_return(bus, -EINVAL);
2900 assert_return(match, -EINVAL);
2901 assert_return(!bus_pid_changed(bus), -ECHILD);
2903 r = bus_match_parse(match, &components, &n_components);
2907 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2911 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2914 bus_match_parse_free(components, n_components);
2919 bool bus_pid_changed(sd_bus *bus) {
2922 /* We don't support people creating a bus connection and
2923 * keeping it around over a fork(). Let's complain. */
2925 return bus->original_pid != getpid();
2928 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2929 sd_bus *bus = userdata;
2934 r = sd_bus_process(bus, NULL);
2941 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2942 sd_bus *bus = userdata;
2947 r = sd_bus_process(bus, NULL);
2954 static int prepare_callback(sd_event_source *s, void *userdata) {
2955 sd_bus *bus = userdata;
2962 e = sd_bus_get_events(bus);
2966 if (bus->output_fd != bus->input_fd) {
2968 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2972 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2976 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2981 r = sd_bus_get_timeout(bus, &until);
2987 j = sd_event_source_set_time(bus->time_event_source, until);
2992 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2999 static int quit_callback(sd_event_source *event, void *userdata) {
3000 sd_bus *bus = userdata;
3010 static int attach_io_events(sd_bus *bus) {
3015 if (bus->input_fd < 0)
3021 if (!bus->input_io_event_source) {
3022 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3026 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3030 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3034 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3036 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3041 if (bus->output_fd != bus->input_fd) {
3042 assert(bus->output_fd >= 0);
3044 if (!bus->output_io_event_source) {
3045 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3049 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3053 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3055 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3064 static void detach_io_events(sd_bus *bus) {
3067 if (bus->input_io_event_source) {
3068 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3069 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3072 if (bus->output_io_event_source) {
3073 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3074 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3078 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3081 assert_return(bus, -EINVAL);
3082 assert_return(!bus->event, -EBUSY);
3084 assert(!bus->input_io_event_source);
3085 assert(!bus->output_io_event_source);
3086 assert(!bus->time_event_source);
3089 bus->event = sd_event_ref(event);
3091 r = sd_event_default(&bus->event);
3096 bus->event_priority = priority;
3098 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3102 r = sd_event_source_set_priority(bus->time_event_source, priority);
3106 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3110 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3114 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3118 r = attach_io_events(bus);
3125 sd_bus_detach_event(bus);
3129 _public_ int sd_bus_detach_event(sd_bus *bus) {
3130 assert_return(bus, -EINVAL);
3135 detach_io_events(bus);
3137 if (bus->time_event_source) {
3138 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3139 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3142 if (bus->quit_event_source) {
3143 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3144 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3147 bus->event = sd_event_unref(bus->event);
3151 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3152 assert_return(bus, NULL);
3157 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3158 assert_return(bus, NULL);
3160 return bus->current_message;
3163 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3164 assert_return(bus, NULL);
3166 return bus->current_slot;
3169 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3170 assert_return(bus, NULL);
3172 return bus->current_handler;
3175 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3176 assert_return(bus, NULL);
3178 return bus->current_userdata;
3181 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3186 assert(default_bus);
3189 return !!*default_bus;
3192 *ret = sd_bus_ref(*default_bus);
3200 b->default_bus_ptr = default_bus;
3208 _public_ int sd_bus_default_system(sd_bus **ret) {
3209 static thread_local sd_bus *default_system_bus = NULL;
3211 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3214 _public_ int sd_bus_default_user(sd_bus **ret) {
3215 static thread_local sd_bus *default_user_bus = NULL;
3217 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3220 _public_ int sd_bus_default(sd_bus **ret) {
3224 /* Let's try our best to reuse another cached connection. If
3225 * the starter bus type is set, connect via our normal
3226 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3227 * we can share the connection with the user/system default
3230 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3232 if (streq(e, "system"))
3233 return sd_bus_default_system(ret);
3234 else if (STR_IN_SET(e, "user", "session"))
3235 return sd_bus_default_user(ret);
3238 /* No type is specified, so we have not other option than to
3239 * use the starter address if it is set. */
3241 e = secure_getenv("DBUS_STARTER_ADDRESS");
3243 static thread_local sd_bus *default_starter_bus = NULL;
3245 return bus_default(sd_bus_open, &default_starter_bus, ret);
3248 /* Finally, if nothing is set use the cached connection for
3249 * the right scope */
3251 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3252 return sd_bus_default_user(ret);
3254 return sd_bus_default_system(ret);
3257 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3258 assert_return(b, -EINVAL);
3259 assert_return(tid, -EINVAL);
3260 assert_return(!bus_pid_changed(b), -ECHILD);
3268 return sd_event_get_tid(b->event, tid);
3273 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3274 _cleanup_free_ char *e = NULL;
3277 assert_return(object_path_is_valid(prefix), -EINVAL);
3278 assert_return(external_id, -EINVAL);
3279 assert_return(ret_path, -EINVAL);
3281 e = bus_label_escape(external_id);
3285 ret = strjoin(prefix, "/", e, NULL);
3293 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3297 assert_return(object_path_is_valid(path), -EINVAL);
3298 assert_return(object_path_is_valid(prefix), -EINVAL);
3299 assert_return(external_id, -EINVAL);
3301 e = object_path_startswith(path, prefix);
3303 *external_id = NULL;
3307 ret = bus_label_unescape(e);
3315 _public_ int sd_bus_try_close(sd_bus *bus) {
3318 assert_return(bus, -EINVAL);
3319 assert_return(!bus_pid_changed(bus), -ECHILD);
3321 if (!bus->is_kernel)
3324 if (!BUS_IS_OPEN(bus->state))
3327 if (bus->rqueue_size > 0)
3330 if (bus->wqueue_size > 0)
3333 r = bus_kernel_try_close(bus);
3341 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3342 assert_return(bus, -EINVAL);
3343 assert_return(description, -EINVAL);
3344 assert_return(bus->description, -ENXIO);
3345 assert_return(!bus_pid_changed(bus), -ECHILD);
3347 *description = bus->description;
3351 int bus_get_root_path(sd_bus *bus) {
3354 if (bus->cgroup_root)
3357 r = cg_get_root_path(&bus->cgroup_root);
3359 bus->cgroup_root = strdup("/");
3360 if (!bus->cgroup_root)