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, *pid = NULL;
767 while (**p != 0 && **p != ';') {
768 r = parse_address_key(p, "guid", guid);
774 r = parse_address_key(p, "machine", &machine);
780 r = parse_address_key(p, "pid", &pid);
789 if (!machine == !pid)
793 if (!machine_name_is_valid(machine))
797 b->machine = machine;
805 r = parse_pid(pid, &b->nspid);
811 b->sockaddr.un.sun_family = AF_UNIX;
812 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
813 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
818 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
819 _cleanup_free_ char *machine = NULL, *pid = NULL;
827 while (**p != 0 && **p != ';') {
828 r = parse_address_key(p, "guid", guid);
834 r = parse_address_key(p, "machine", &machine);
840 r = parse_address_key(p, "pid", &pid);
849 if (!machine == !pid)
853 if (!machine_name_is_valid(machine))
857 b->machine = machine;
865 r = parse_pid(pid, &b->nspid);
872 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
879 static void bus_reset_parsed_address(sd_bus *b) {
883 b->sockaddr_size = 0;
884 strv_free(b->exec_argv);
888 b->server_id = SD_ID128_NULL;
896 static int bus_parse_next_address(sd_bus *b) {
897 _cleanup_free_ char *guid = NULL;
905 if (b->address[b->address_index] == 0)
908 bus_reset_parsed_address(b);
910 a = b->address + b->address_index;
919 if (startswith(a, "unix:")) {
922 r = parse_unix_address(b, &a, &guid);
927 } else if (startswith(a, "tcp:")) {
930 r = parse_tcp_address(b, &a, &guid);
936 } else if (startswith(a, "unixexec:")) {
939 r = parse_exec_address(b, &a, &guid);
945 } else if (startswith(a, "kernel:")) {
948 r = parse_kernel_address(b, &a, &guid);
953 } else if (startswith(a, "x-machine-unix:")) {
956 r = parse_container_unix_address(b, &a, &guid);
961 } else if (startswith(a, "x-machine-kernel:")) {
964 r = parse_container_kernel_address(b, &a, &guid);
977 r = sd_id128_from_string(guid, &b->server_id);
982 b->address_index = a - b->address;
986 static int bus_start_address(sd_bus *b) {
992 bool skipped = false;
997 r = bus_socket_exec(b);
998 else if ((b->nspid > 0 || b->machine) && b->kernel)
999 r = bus_container_connect_kernel(b);
1000 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1001 r = bus_container_connect_socket(b);
1003 r = bus_kernel_connect(b);
1004 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1005 r = bus_socket_connect(b);
1011 r = attach_io_events(b);
1016 b->last_connect_error = -r;
1019 r = bus_parse_next_address(b);
1023 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1027 int bus_next_address(sd_bus *b) {
1030 bus_reset_parsed_address(b);
1031 return bus_start_address(b);
1034 static int bus_start_fd(sd_bus *b) {
1039 assert(b->input_fd >= 0);
1040 assert(b->output_fd >= 0);
1042 r = fd_nonblock(b->input_fd, true);
1046 r = fd_cloexec(b->input_fd, true);
1050 if (b->input_fd != b->output_fd) {
1051 r = fd_nonblock(b->output_fd, true);
1055 r = fd_cloexec(b->output_fd, true);
1060 if (fstat(b->input_fd, &st) < 0)
1063 if (S_ISCHR(b->input_fd))
1064 return bus_kernel_take_fd(b);
1066 return bus_socket_take_fd(b);
1069 _public_ int sd_bus_start(sd_bus *bus) {
1072 assert_return(bus, -EINVAL);
1073 assert_return(bus->state == BUS_UNSET, -EPERM);
1074 assert_return(!bus_pid_changed(bus), -ECHILD);
1076 bus->state = BUS_OPENING;
1078 if (bus->is_server && bus->bus_client)
1081 if (bus->input_fd >= 0)
1082 r = bus_start_fd(bus);
1083 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1084 r = bus_start_address(bus);
1093 return bus_send_hello(bus);
1096 _public_ int sd_bus_open(sd_bus **ret) {
1101 assert_return(ret, -EINVAL);
1103 /* Let's connect to the starter bus if it is set, and
1104 * otherwise to the bus that is appropropriate for the scope
1105 * we are running in */
1107 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1109 if (streq(e, "system"))
1110 return sd_bus_open_system(ret);
1111 else if (STR_IN_SET(e, "session", "user"))
1112 return sd_bus_open_user(ret);
1115 e = secure_getenv("DBUS_STARTER_ADDRESS");
1117 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1118 return sd_bus_open_user(ret);
1120 return sd_bus_open_system(ret);
1127 r = sd_bus_set_address(b, e);
1131 b->bus_client = true;
1133 /* We don't know whether the bus is trusted or not, so better
1134 * be safe, and authenticate everything */
1136 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1137 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1139 r = sd_bus_start(b);
1151 int bus_set_address_system(sd_bus *b) {
1155 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1157 return sd_bus_set_address(b, e);
1159 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1162 _public_ int sd_bus_open_system(sd_bus **ret) {
1166 assert_return(ret, -EINVAL);
1172 r = bus_set_address_system(b);
1176 b->bus_client = true;
1177 b->is_system = true;
1179 /* Let's do per-method access control on the system bus. We
1180 * need the caller's UID and capability set for that. */
1182 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1183 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1185 r = sd_bus_start(b);
1197 int bus_set_address_user(sd_bus *b) {
1202 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1204 return sd_bus_set_address(b, e);
1206 e = secure_getenv("XDG_RUNTIME_DIR");
1208 _cleanup_free_ char *ee = NULL;
1210 ee = bus_address_escape(e);
1215 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1217 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1221 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1223 return -ECONNREFUSED;
1233 _public_ int sd_bus_open_user(sd_bus **ret) {
1237 assert_return(ret, -EINVAL);
1243 r = bus_set_address_user(b);
1247 b->bus_client = true;
1250 /* We don't do any per-method access control on the user
1254 r = sd_bus_start(b);
1266 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1267 _cleanup_free_ char *e = NULL;
1268 char *m = NULL, *c = NULL;
1273 /* Let's see if we shall enter some container */
1274 m = strchr(host, ':');
1278 /* Let's make sure this is not a port of some kind,
1279 * and is a valid machine name. */
1280 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1283 /* Cut out the host part */
1284 t = strndupa(host, m - host - 1);
1285 e = bus_address_escape(t);
1289 c = strappenda(",argv4=--machine=", m);
1294 e = bus_address_escape(host);
1299 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1306 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1310 assert_return(host, -EINVAL);
1311 assert_return(ret, -EINVAL);
1313 r = sd_bus_new(&bus);
1317 r = bus_set_address_system_remote(bus, host);
1321 bus->bus_client = true;
1322 bus->trusted = false;
1323 bus->is_system = true;
1325 r = sd_bus_start(bus);
1337 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1338 _cleanup_free_ char *e = NULL;
1343 e = bus_address_escape(machine);
1348 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1350 b->address = strjoin("x-machine-unix:machine=", e, NULL);
1358 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1362 assert_return(machine, -EINVAL);
1363 assert_return(ret, -EINVAL);
1364 assert_return(machine_name_is_valid(machine), -EINVAL);
1366 r = sd_bus_new(&bus);
1370 r = bus_set_address_system_machine(bus, machine);
1374 bus->bus_client = true;
1375 bus->trusted = false;
1376 bus->is_system = true;
1378 r = sd_bus_start(bus);
1390 _public_ void sd_bus_close(sd_bus *bus) {
1394 if (bus->state == BUS_CLOSED)
1396 if (bus_pid_changed(bus))
1399 bus->state = BUS_CLOSED;
1401 sd_bus_detach_event(bus);
1403 /* Drop all queued messages so that they drop references to
1404 * the bus object and the bus may be freed */
1405 bus_reset_queues(bus);
1407 if (!bus->is_kernel)
1410 /* We'll leave the fd open in case this is a kernel bus, since
1411 * there might still be memblocks around that reference this
1412 * bus, and they might need to invoke the KDBUS_CMD_FREE
1413 * ioctl on the fd when they are freed. */
1416 static void bus_enter_closing(sd_bus *bus) {
1419 if (bus->state != BUS_OPENING &&
1420 bus->state != BUS_AUTHENTICATING &&
1421 bus->state != BUS_HELLO &&
1422 bus->state != BUS_RUNNING)
1425 bus->state = BUS_CLOSING;
1428 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1429 assert_return(bus, NULL);
1431 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1436 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1442 i = REFCNT_DEC(bus->n_ref);
1450 _public_ int sd_bus_is_open(sd_bus *bus) {
1452 assert_return(bus, -EINVAL);
1453 assert_return(!bus_pid_changed(bus), -ECHILD);
1455 return BUS_IS_OPEN(bus->state);
1458 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1461 assert_return(bus, -EINVAL);
1462 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1463 assert_return(!bus_pid_changed(bus), -ECHILD);
1465 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1468 if (type == SD_BUS_TYPE_UNIX_FD) {
1469 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1472 r = bus_ensure_running(bus);
1476 return bus->can_fds;
1479 return bus_type_is_valid(type);
1482 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1485 assert_return(bus, -EINVAL);
1486 assert_return(id, -EINVAL);
1487 assert_return(!bus_pid_changed(bus), -ECHILD);
1489 r = bus_ensure_running(bus);
1493 *id = bus->server_id;
1497 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1502 /* If we copy the same message to multiple
1503 * destinations, avoid using the same cookie
1505 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1510 timeout = BUS_DEFAULT_TIMEOUT;
1512 return bus_message_seal(m, ++b->cookie, timeout);
1515 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1518 /* Do packet version and endianness already match? */
1519 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1520 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1523 /* No? Then remarshal! */
1524 return bus_message_remarshal(b, m);
1527 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1531 /* The bus specification says the serial number cannot be 0,
1532 * hence let's fill something in for synthetic messages. Since
1533 * synthetic messages might have a fake sender and we don't
1534 * want to interfere with the real sender's serial numbers we
1535 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1536 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1537 * even though kdbus can do 64bit. */
1539 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1542 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1549 r = bus_kernel_write_message(bus, m, hint_sync_call);
1551 r = bus_socket_write_message(bus, m, idx);
1556 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1557 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1558 bus_message_type_to_string(m->header->type),
1559 strna(sd_bus_message_get_sender(m)),
1560 strna(sd_bus_message_get_destination(m)),
1561 strna(sd_bus_message_get_path(m)),
1562 strna(sd_bus_message_get_interface(m)),
1563 strna(sd_bus_message_get_member(m)),
1564 BUS_MESSAGE_COOKIE(m),
1566 strna(m->error.message));
1571 static int dispatch_wqueue(sd_bus *bus) {
1575 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1577 while (bus->wqueue_size > 0) {
1579 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1583 /* Didn't do anything this time */
1585 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1586 /* Fully written. Let's drop the entry from
1589 * This isn't particularly optimized, but
1590 * well, this is supposed to be our worst-case
1591 * buffer only, and the socket buffer is
1592 * supposed to be our primary buffer, and if
1593 * it got full, then all bets are off
1596 bus->wqueue_size --;
1597 sd_bus_message_unref(bus->wqueue[0]);
1598 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1608 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1612 return bus_kernel_read_message(bus, hint_priority, priority);
1614 return bus_socket_read_message(bus);
1617 int bus_rqueue_make_room(sd_bus *bus) {
1620 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1623 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1629 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1634 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1636 /* Note that the priority logic is only available on kdbus,
1637 * where the rqueue is unused. We check the rqueue here
1638 * anyway, because it's simple... */
1641 if (bus->rqueue_size > 0) {
1642 /* Dispatch a queued message */
1644 *m = bus->rqueue[0];
1645 bus->rqueue_size --;
1646 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1650 /* Try to read a new message */
1651 r = bus_read_message(bus, hint_priority, priority);
1661 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1662 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1665 assert_return(bus, -EINVAL);
1666 assert_return(m, -EINVAL);
1667 assert_return(!bus_pid_changed(bus), -ECHILD);
1668 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1670 if (!BUS_IS_OPEN(bus->state))
1674 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1681 /* If the cookie number isn't kept, then we know that no reply
1683 if (!cookie && !m->sealed)
1684 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1686 r = bus_seal_message(bus, m, 0);
1690 /* Remarshall if we have to. This will possibly unref the
1691 * message and place a replacement in m */
1692 r = bus_remarshal_message(bus, &m);
1696 /* If this is a reply and no reply was requested, then let's
1697 * suppress this, if we can */
1698 if (m->dont_send && !cookie)
1701 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1704 r = bus_write_message(bus, m, hint_sync_call, &idx);
1706 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1707 bus_enter_closing(bus);
1712 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1713 /* Wasn't fully written. So let's remember how
1714 * much was written. Note that the first entry
1715 * of the wqueue array is always allocated so
1716 * that we always can remember how much was
1718 bus->wqueue[0] = sd_bus_message_ref(m);
1719 bus->wqueue_size = 1;
1723 /* Just append it to the queue. */
1725 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1728 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1731 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1735 *cookie = BUS_MESSAGE_COOKIE(m);
1740 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1741 return bus_send_internal(bus, m, cookie, false);
1744 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1747 assert_return(bus, -EINVAL);
1748 assert_return(m, -EINVAL);
1749 assert_return(!bus_pid_changed(bus), -ECHILD);
1751 if (!BUS_IS_OPEN(bus->state))
1754 if (!streq_ptr(m->destination, destination)) {
1759 r = sd_bus_message_set_destination(m, destination);
1764 return sd_bus_send(bus, m, cookie);
1767 static usec_t calc_elapse(uint64_t usec) {
1768 if (usec == (uint64_t) -1)
1771 return now(CLOCK_MONOTONIC) + usec;
1774 static int timeout_compare(const void *a, const void *b) {
1775 const struct reply_callback *x = a, *y = b;
1777 if (x->timeout != 0 && y->timeout == 0)
1780 if (x->timeout == 0 && y->timeout != 0)
1783 if (x->timeout < y->timeout)
1786 if (x->timeout > y->timeout)
1792 _public_ int sd_bus_call_async(
1796 sd_bus_message_handler_t callback,
1800 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1801 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1804 assert_return(bus, -EINVAL);
1805 assert_return(m, -EINVAL);
1806 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1807 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1808 assert_return(callback, -EINVAL);
1809 assert_return(!bus_pid_changed(bus), -ECHILD);
1810 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1812 if (!BUS_IS_OPEN(bus->state))
1815 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1819 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1823 r = bus_seal_message(bus, m, usec);
1827 r = bus_remarshal_message(bus, &m);
1831 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1835 s->reply_callback.callback = callback;
1837 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1838 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1840 s->reply_callback.cookie = 0;
1844 s->reply_callback.timeout = calc_elapse(m->timeout);
1845 if (s->reply_callback.timeout != 0) {
1846 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1848 s->reply_callback.timeout = 0;
1853 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1864 int bus_ensure_running(sd_bus *bus) {
1869 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1871 if (bus->state == BUS_RUNNING)
1875 r = sd_bus_process(bus, NULL);
1878 if (bus->state == BUS_RUNNING)
1883 r = sd_bus_wait(bus, (uint64_t) -1);
1889 _public_ int sd_bus_call(
1893 sd_bus_error *error,
1894 sd_bus_message **reply) {
1896 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1902 assert_return(bus, -EINVAL);
1903 assert_return(m, -EINVAL);
1904 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1905 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1906 assert_return(!bus_error_is_dirty(error), -EINVAL);
1907 assert_return(!bus_pid_changed(bus), -ECHILD);
1908 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1910 if (!BUS_IS_OPEN(bus->state))
1913 r = bus_ensure_running(bus);
1917 i = bus->rqueue_size;
1919 r = bus_seal_message(bus, m, usec);
1923 r = bus_remarshal_message(bus, &m);
1927 r = bus_send_internal(bus, m, &cookie, true);
1931 timeout = calc_elapse(m->timeout);
1936 while (i < bus->rqueue_size) {
1937 sd_bus_message *incoming = NULL;
1939 incoming = bus->rqueue[i];
1941 if (incoming->reply_cookie == cookie) {
1942 /* Found a match! */
1944 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1947 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1949 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1953 sd_bus_message_unref(incoming);
1958 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1960 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1961 r = sd_bus_error_copy(error, &incoming->error);
1965 sd_bus_message_unref(incoming);
1968 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1971 streq(bus->unique_name, incoming->sender)) {
1973 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1976 /* Our own message? Somebody is trying
1977 * to send its own client a message,
1978 * let's not dead-lock, let's fail
1981 sd_bus_message_unref(incoming);
1985 /* Try to read more, right-away */
1989 r = bus_read_message(bus, false, 0);
1991 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1992 bus_enter_closing(bus);
2004 n = now(CLOCK_MONOTONIC);
2010 left = (uint64_t) -1;
2012 r = bus_poll(bus, true, left);
2018 r = dispatch_wqueue(bus);
2020 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2021 bus_enter_closing(bus);
2030 _public_ int sd_bus_get_fd(sd_bus *bus) {
2032 assert_return(bus, -EINVAL);
2033 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2034 assert_return(!bus_pid_changed(bus), -ECHILD);
2036 return bus->input_fd;
2039 _public_ int sd_bus_get_events(sd_bus *bus) {
2042 assert_return(bus, -EINVAL);
2043 assert_return(!bus_pid_changed(bus), -ECHILD);
2045 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2048 if (bus->state == BUS_OPENING)
2050 else if (bus->state == BUS_AUTHENTICATING) {
2052 if (bus_socket_auth_needs_write(bus))
2057 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2058 if (bus->rqueue_size <= 0)
2060 if (bus->wqueue_size > 0)
2067 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2068 struct reply_callback *c;
2070 assert_return(bus, -EINVAL);
2071 assert_return(timeout_usec, -EINVAL);
2072 assert_return(!bus_pid_changed(bus), -ECHILD);
2074 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2077 if (bus->track_queue) {
2082 if (bus->state == BUS_CLOSING) {
2087 if (bus->state == BUS_AUTHENTICATING) {
2088 *timeout_usec = bus->auth_timeout;
2092 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2093 *timeout_usec = (uint64_t) -1;
2097 if (bus->rqueue_size > 0) {
2102 c = prioq_peek(bus->reply_callbacks_prioq);
2104 *timeout_usec = (uint64_t) -1;
2108 if (c->timeout == 0) {
2109 *timeout_usec = (uint64_t) -1;
2113 *timeout_usec = c->timeout;
2117 static int process_timeout(sd_bus *bus) {
2118 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2119 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2120 struct reply_callback *c;
2127 c = prioq_peek(bus->reply_callbacks_prioq);
2131 n = now(CLOCK_MONOTONIC);
2135 r = bus_message_new_synthetic_error(
2138 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2143 r = bus_seal_synthetic_message(bus, m);
2147 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2150 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2153 slot = container_of(c, sd_bus_slot, reply_callback);
2155 bus->iteration_counter ++;
2157 bus->current_message = m;
2158 bus->current_slot = sd_bus_slot_ref(slot);
2159 bus->current_handler = c->callback;
2160 bus->current_userdata = slot->userdata;
2161 r = c->callback(bus, m, slot->userdata, &error_buffer);
2162 bus->current_userdata = NULL;
2163 bus->current_handler = NULL;
2164 bus->current_slot = NULL;
2165 bus->current_message = NULL;
2167 if (slot->floating) {
2168 bus_slot_disconnect(slot);
2169 sd_bus_slot_unref(slot);
2172 sd_bus_slot_unref(slot);
2174 return bus_maybe_reply_error(m, r, &error_buffer);
2177 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2181 if (bus->state != BUS_HELLO)
2184 /* Let's make sure the first message on the bus is the HELLO
2185 * reply. But note that we don't actually parse the message
2186 * here (we leave that to the usual handling), we just verify
2187 * we don't let any earlier msg through. */
2189 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2190 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2193 if (m->reply_cookie != 1)
2199 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2200 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2201 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2202 struct reply_callback *c;
2209 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2210 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2213 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2216 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2219 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2225 slot = container_of(c, sd_bus_slot, reply_callback);
2227 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2229 /* If the reply contained a file descriptor which we
2230 * didn't want we pass an error instead. */
2232 r = bus_message_new_synthetic_error(
2235 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2240 r = bus_seal_synthetic_message(bus, synthetic_reply);
2244 m = synthetic_reply;
2246 r = sd_bus_message_rewind(m, true);
2251 if (c->timeout != 0) {
2252 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2256 bus->current_slot = sd_bus_slot_ref(slot);
2257 bus->current_handler = c->callback;
2258 bus->current_userdata = slot->userdata;
2259 r = c->callback(bus, m, slot->userdata, &error_buffer);
2260 bus->current_userdata = NULL;
2261 bus->current_handler = NULL;
2262 bus->current_slot = NULL;
2264 if (slot->floating) {
2265 bus_slot_disconnect(slot);
2266 sd_bus_slot_unref(slot);
2269 sd_bus_slot_unref(slot);
2271 return bus_maybe_reply_error(m, r, &error_buffer);
2274 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2275 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2276 struct filter_callback *l;
2283 bus->filter_callbacks_modified = false;
2285 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2288 if (bus->filter_callbacks_modified)
2291 /* Don't run this more than once per iteration */
2292 if (l->last_iteration == bus->iteration_counter)
2295 l->last_iteration = bus->iteration_counter;
2297 r = sd_bus_message_rewind(m, true);
2301 slot = container_of(l, sd_bus_slot, filter_callback);
2303 bus->current_slot = sd_bus_slot_ref(slot);
2304 bus->current_handler = l->callback;
2305 bus->current_userdata = slot->userdata;
2306 r = l->callback(bus, m, slot->userdata, &error_buffer);
2307 bus->current_userdata = NULL;
2308 bus->current_handler = NULL;
2309 bus->current_slot = sd_bus_slot_unref(slot);
2311 r = bus_maybe_reply_error(m, r, &error_buffer);
2317 } while (bus->filter_callbacks_modified);
2322 static int process_match(sd_bus *bus, sd_bus_message *m) {
2329 bus->match_callbacks_modified = false;
2331 r = bus_match_run(bus, &bus->match_callbacks, m);
2335 } while (bus->match_callbacks_modified);
2340 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2341 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2347 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2350 if (bus->manual_peer_interface)
2353 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2356 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2359 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2362 if (streq_ptr(m->member, "Ping"))
2363 r = sd_bus_message_new_method_return(m, &reply);
2364 else if (streq_ptr(m->member, "GetMachineId")) {
2368 r = sd_id128_get_machine(&id);
2372 r = sd_bus_message_new_method_return(m, &reply);
2376 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2378 r = sd_bus_message_new_method_errorf(
2380 SD_BUS_ERROR_UNKNOWN_METHOD,
2381 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2387 r = sd_bus_send(bus, reply, NULL);
2394 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2398 /* If we got a message with a file descriptor which we didn't
2399 * want to accept, then let's drop it. How can this even
2400 * happen? For example, when the kernel queues a message into
2401 * an activatable names's queue which allows fds, and then is
2402 * delivered to us later even though we ourselves did not
2405 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2411 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2414 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2415 return 1; /* just eat it up */
2417 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2420 static int process_message(sd_bus *bus, sd_bus_message *m) {
2426 bus->current_message = m;
2427 bus->iteration_counter++;
2429 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2430 bus_message_type_to_string(m->header->type),
2431 strna(sd_bus_message_get_sender(m)),
2432 strna(sd_bus_message_get_destination(m)),
2433 strna(sd_bus_message_get_path(m)),
2434 strna(sd_bus_message_get_interface(m)),
2435 strna(sd_bus_message_get_member(m)),
2436 BUS_MESSAGE_COOKIE(m),
2438 strna(m->error.message));
2440 r = process_hello(bus, m);
2444 r = process_reply(bus, m);
2448 r = process_fd_check(bus, m);
2452 r = process_filter(bus, m);
2456 r = process_match(bus, m);
2460 r = process_builtin(bus, m);
2464 r = bus_process_object(bus, m);
2467 bus->current_message = NULL;
2471 static int dispatch_track(sd_bus *bus) {
2474 if (!bus->track_queue)
2477 bus_track_dispatch(bus->track_queue);
2481 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2482 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2486 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2488 r = process_timeout(bus);
2492 r = dispatch_wqueue(bus);
2496 r = dispatch_track(bus);
2500 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2506 r = process_message(bus, m);
2511 r = sd_bus_message_rewind(m, true);
2520 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2522 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2523 strna(sd_bus_message_get_sender(m)),
2524 strna(sd_bus_message_get_path(m)),
2525 strna(sd_bus_message_get_interface(m)),
2526 strna(sd_bus_message_get_member(m)));
2528 r = sd_bus_reply_method_errorf(
2530 SD_BUS_ERROR_UNKNOWN_OBJECT,
2531 "Unknown object '%s'.", m->path);
2545 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2546 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2547 struct reply_callback *c;
2551 assert(bus->state == BUS_CLOSING);
2553 c = ordered_hashmap_first(bus->reply_callbacks);
2555 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2558 /* First, fail all outstanding method calls */
2559 r = bus_message_new_synthetic_error(
2562 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2567 r = bus_seal_synthetic_message(bus, m);
2571 if (c->timeout != 0) {
2572 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2576 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2579 slot = container_of(c, sd_bus_slot, reply_callback);
2581 bus->iteration_counter++;
2583 bus->current_message = m;
2584 bus->current_slot = sd_bus_slot_ref(slot);
2585 bus->current_handler = c->callback;
2586 bus->current_userdata = slot->userdata;
2587 r = c->callback(bus, m, slot->userdata, &error_buffer);
2588 bus->current_userdata = NULL;
2589 bus->current_handler = NULL;
2590 bus->current_slot = NULL;
2591 bus->current_message = NULL;
2593 if (slot->floating) {
2594 bus_slot_disconnect(slot);
2595 sd_bus_slot_unref(slot);
2598 sd_bus_slot_unref(slot);
2600 return bus_maybe_reply_error(m, r, &error_buffer);
2603 /* Then, synthesize a Disconnected message */
2604 r = sd_bus_message_new_signal(
2607 "/org/freedesktop/DBus/Local",
2608 "org.freedesktop.DBus.Local",
2613 bus_message_set_sender_local(bus, m);
2615 r = bus_seal_synthetic_message(bus, m);
2621 bus->current_message = m;
2622 bus->iteration_counter++;
2624 r = process_filter(bus, m);
2628 r = process_match(bus, m);
2640 bus->current_message = NULL;
2645 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2646 BUS_DONT_DESTROY(bus);
2649 /* Returns 0 when we didn't do anything. This should cause the
2650 * caller to invoke sd_bus_wait() before returning the next
2651 * time. Returns > 0 when we did something, which possibly
2652 * means *ret is filled in with an unprocessed message. */
2654 assert_return(bus, -EINVAL);
2655 assert_return(!bus_pid_changed(bus), -ECHILD);
2657 /* We don't allow recursively invoking sd_bus_process(). */
2658 assert_return(!bus->current_message, -EBUSY);
2659 assert(!bus->current_slot);
2661 switch (bus->state) {
2670 r = bus_socket_process_opening(bus);
2671 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2672 bus_enter_closing(bus);
2680 case BUS_AUTHENTICATING:
2681 r = bus_socket_process_authenticating(bus);
2682 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2683 bus_enter_closing(bus);
2695 r = process_running(bus, hint_priority, priority, ret);
2696 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2697 bus_enter_closing(bus);
2707 return process_closing(bus, ret);
2710 assert_not_reached("Unknown state");
2713 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2714 return bus_process_internal(bus, false, 0, ret);
2717 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2718 return bus_process_internal(bus, true, priority, ret);
2721 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2722 struct pollfd p[2] = {};
2725 usec_t m = USEC_INFINITY;
2729 if (bus->state == BUS_CLOSING)
2732 if (!BUS_IS_OPEN(bus->state))
2735 e = sd_bus_get_events(bus);
2740 /* The caller really needs some more data, he doesn't
2741 * care about what's already read, or any timeouts
2742 * except its own. */
2746 /* The caller wants to process if there's something to
2747 * process, but doesn't care otherwise */
2749 r = sd_bus_get_timeout(bus, &until);
2754 nw = now(CLOCK_MONOTONIC);
2755 m = until > nw ? until - nw : 0;
2759 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2762 p[0].fd = bus->input_fd;
2763 if (bus->output_fd == bus->input_fd) {
2767 p[0].events = e & POLLIN;
2768 p[1].fd = bus->output_fd;
2769 p[1].events = e & POLLOUT;
2773 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2777 return r > 0 ? 1 : 0;
2780 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2782 assert_return(bus, -EINVAL);
2783 assert_return(!bus_pid_changed(bus), -ECHILD);
2785 if (bus->state == BUS_CLOSING)
2788 if (!BUS_IS_OPEN(bus->state))
2791 if (bus->rqueue_size > 0)
2794 return bus_poll(bus, false, timeout_usec);
2797 _public_ int sd_bus_flush(sd_bus *bus) {
2800 assert_return(bus, -EINVAL);
2801 assert_return(!bus_pid_changed(bus), -ECHILD);
2803 if (bus->state == BUS_CLOSING)
2806 if (!BUS_IS_OPEN(bus->state))
2809 r = bus_ensure_running(bus);
2813 if (bus->wqueue_size <= 0)
2817 r = dispatch_wqueue(bus);
2819 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2820 bus_enter_closing(bus);
2827 if (bus->wqueue_size <= 0)
2830 r = bus_poll(bus, false, (uint64_t) -1);
2836 _public_ int sd_bus_add_filter(
2839 sd_bus_message_handler_t callback,
2844 assert_return(bus, -EINVAL);
2845 assert_return(callback, -EINVAL);
2846 assert_return(!bus_pid_changed(bus), -ECHILD);
2848 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2852 s->filter_callback.callback = callback;
2854 bus->filter_callbacks_modified = true;
2855 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2863 _public_ int sd_bus_add_match(
2867 sd_bus_message_handler_t callback,
2870 struct bus_match_component *components = NULL;
2871 unsigned n_components = 0;
2872 sd_bus_slot *s = NULL;
2875 assert_return(bus, -EINVAL);
2876 assert_return(match, -EINVAL);
2877 assert_return(!bus_pid_changed(bus), -ECHILD);
2879 r = bus_match_parse(match, &components, &n_components);
2883 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2889 s->match_callback.callback = callback;
2890 s->match_callback.cookie = ++bus->match_cookie;
2892 if (bus->bus_client) {
2894 if (!bus->is_kernel) {
2895 /* When this is not a kernel transport, we
2896 * store the original match string, so that we
2897 * can use it to remove the match again */
2899 s->match_callback.match_string = strdup(match);
2900 if (!s->match_callback.match_string) {
2906 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2911 bus->match_callbacks_modified = true;
2912 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2921 bus_match_parse_free(components, n_components);
2922 sd_bus_slot_unref(s);
2927 int bus_remove_match_by_string(
2930 sd_bus_message_handler_t callback,
2933 struct bus_match_component *components = NULL;
2934 unsigned n_components = 0;
2935 struct match_callback *c;
2938 assert_return(bus, -EINVAL);
2939 assert_return(match, -EINVAL);
2940 assert_return(!bus_pid_changed(bus), -ECHILD);
2942 r = bus_match_parse(match, &components, &n_components);
2946 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2950 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2953 bus_match_parse_free(components, n_components);
2958 bool bus_pid_changed(sd_bus *bus) {
2961 /* We don't support people creating a bus connection and
2962 * keeping it around over a fork(). Let's complain. */
2964 return bus->original_pid != getpid();
2967 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2968 sd_bus *bus = userdata;
2973 r = sd_bus_process(bus, NULL);
2980 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2981 sd_bus *bus = userdata;
2986 r = sd_bus_process(bus, NULL);
2993 static int prepare_callback(sd_event_source *s, void *userdata) {
2994 sd_bus *bus = userdata;
3001 e = sd_bus_get_events(bus);
3005 if (bus->output_fd != bus->input_fd) {
3007 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3011 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3015 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3020 r = sd_bus_get_timeout(bus, &until);
3026 j = sd_event_source_set_time(bus->time_event_source, until);
3031 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3038 static int quit_callback(sd_event_source *event, void *userdata) {
3039 sd_bus *bus = userdata;
3049 static int attach_io_events(sd_bus *bus) {
3054 if (bus->input_fd < 0)
3060 if (!bus->input_io_event_source) {
3061 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3065 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3069 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3073 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3075 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3080 if (bus->output_fd != bus->input_fd) {
3081 assert(bus->output_fd >= 0);
3083 if (!bus->output_io_event_source) {
3084 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3088 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3092 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3094 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3103 static void detach_io_events(sd_bus *bus) {
3106 if (bus->input_io_event_source) {
3107 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3108 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3111 if (bus->output_io_event_source) {
3112 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3113 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3117 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3120 assert_return(bus, -EINVAL);
3121 assert_return(!bus->event, -EBUSY);
3123 assert(!bus->input_io_event_source);
3124 assert(!bus->output_io_event_source);
3125 assert(!bus->time_event_source);
3128 bus->event = sd_event_ref(event);
3130 r = sd_event_default(&bus->event);
3135 bus->event_priority = priority;
3137 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3141 r = sd_event_source_set_priority(bus->time_event_source, priority);
3145 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3149 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3153 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3157 r = attach_io_events(bus);
3164 sd_bus_detach_event(bus);
3168 _public_ int sd_bus_detach_event(sd_bus *bus) {
3169 assert_return(bus, -EINVAL);
3174 detach_io_events(bus);
3176 if (bus->time_event_source) {
3177 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3178 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3181 if (bus->quit_event_source) {
3182 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3183 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3186 bus->event = sd_event_unref(bus->event);
3190 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3191 assert_return(bus, NULL);
3196 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3197 assert_return(bus, NULL);
3199 return bus->current_message;
3202 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3203 assert_return(bus, NULL);
3205 return bus->current_slot;
3208 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3209 assert_return(bus, NULL);
3211 return bus->current_handler;
3214 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3215 assert_return(bus, NULL);
3217 return bus->current_userdata;
3220 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3225 assert(default_bus);
3228 return !!*default_bus;
3231 *ret = sd_bus_ref(*default_bus);
3239 b->default_bus_ptr = default_bus;
3247 _public_ int sd_bus_default_system(sd_bus **ret) {
3248 static thread_local sd_bus *default_system_bus = NULL;
3250 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3253 _public_ int sd_bus_default_user(sd_bus **ret) {
3254 static thread_local sd_bus *default_user_bus = NULL;
3256 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3259 _public_ int sd_bus_default(sd_bus **ret) {
3263 /* Let's try our best to reuse another cached connection. If
3264 * the starter bus type is set, connect via our normal
3265 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3266 * we can share the connection with the user/system default
3269 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3271 if (streq(e, "system"))
3272 return sd_bus_default_system(ret);
3273 else if (STR_IN_SET(e, "user", "session"))
3274 return sd_bus_default_user(ret);
3277 /* No type is specified, so we have not other option than to
3278 * use the starter address if it is set. */
3280 e = secure_getenv("DBUS_STARTER_ADDRESS");
3282 static thread_local sd_bus *default_starter_bus = NULL;
3284 return bus_default(sd_bus_open, &default_starter_bus, ret);
3287 /* Finally, if nothing is set use the cached connection for
3288 * the right scope */
3290 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3291 return sd_bus_default_user(ret);
3293 return sd_bus_default_system(ret);
3296 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3297 assert_return(b, -EINVAL);
3298 assert_return(tid, -EINVAL);
3299 assert_return(!bus_pid_changed(b), -ECHILD);
3307 return sd_event_get_tid(b->event, tid);
3312 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3313 _cleanup_free_ char *e = NULL;
3316 assert_return(object_path_is_valid(prefix), -EINVAL);
3317 assert_return(external_id, -EINVAL);
3318 assert_return(ret_path, -EINVAL);
3320 e = bus_label_escape(external_id);
3324 ret = strjoin(prefix, "/", e, NULL);
3332 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3336 assert_return(object_path_is_valid(path), -EINVAL);
3337 assert_return(object_path_is_valid(prefix), -EINVAL);
3338 assert_return(external_id, -EINVAL);
3340 e = object_path_startswith(path, prefix);
3342 *external_id = NULL;
3346 ret = bus_label_unescape(e);
3354 _public_ int sd_bus_try_close(sd_bus *bus) {
3357 assert_return(bus, -EINVAL);
3358 assert_return(!bus_pid_changed(bus), -ECHILD);
3360 if (!bus->is_kernel)
3363 if (!BUS_IS_OPEN(bus->state))
3366 if (bus->rqueue_size > 0)
3369 if (bus->wqueue_size > 0)
3372 r = bus_kernel_try_close(bus);
3380 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3381 assert_return(bus, -EINVAL);
3382 assert_return(description, -EINVAL);
3383 assert_return(bus->description, -ENXIO);
3384 assert_return(!bus_pid_changed(bus), -ECHILD);
3386 *description = bus->description;
3390 int bus_get_root_path(sd_bus *bus) {
3393 if (bus->cgroup_root)
3396 r = cg_get_root_path(&bus->cgroup_root);
3398 bus->cgroup_root = strdup("/");
3399 if (!bus->cgroup_root)
3408 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3411 assert_return(bus, -EINVAL);
3412 assert_return(scope, -EINVAL);
3413 assert_return(!bus_pid_changed(bus), -ECHILD);
3415 if (bus->is_kernel) {
3416 _cleanup_free_ char *n = NULL;
3419 r = bus_kernel_get_bus_name(bus, &n);
3423 if (streq(n, "0-system")) {
3428 dash = strchr(n, '-');
3429 if (streq_ptr(dash, "-user")) {
3440 if (bus->is_system) {
3448 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3450 assert_return(bus, -EINVAL);
3451 assert_return(address, -EINVAL);
3452 assert_return(!bus_pid_changed(bus), -ECHILD);
3455 *address = bus->address;
3462 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3463 assert_return(bus, -EINVAL);
3464 assert_return(mask, -EINVAL);
3465 assert_return(!bus_pid_changed(bus), -ECHILD);
3467 *mask = bus->creds_mask;
3471 int sd_bus_is_bus_client(sd_bus *bus) {
3472 assert_return(bus, -EINVAL);
3473 assert_return(!bus_pid_changed(bus), -ECHILD);
3475 return bus->bus_client;
3478 int sd_bus_is_server(sd_bus *bus) {
3479 assert_return(bus, -EINVAL);
3480 assert_return(!bus_pid_changed(bus), -ECHILD);
3482 return bus->is_server;
3485 int sd_bus_is_anonymous(sd_bus *bus) {
3486 assert_return(bus, -EINVAL);
3487 assert_return(!bus_pid_changed(bus), -ECHILD);
3489 return bus->anonymous_auth;
3492 int sd_bus_is_trusted(sd_bus *bus) {
3493 assert_return(bus, -EINVAL);
3494 assert_return(!bus_pid_changed(bus), -ECHILD);
3496 return bus->trusted;
3499 int sd_bus_is_monitor(sd_bus *bus) {
3500 assert_return(bus, -EINVAL);
3501 assert_return(!bus_pid_changed(bus), -ECHILD);
3503 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);