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/>.
35 #include "cgroup-util.h"
36 #include "bus-label.h"
39 #include "bus-internal.h"
40 #include "bus-message.h"
42 #include "bus-socket.h"
43 #include "bus-kernel.h"
44 #include "bus-control.h"
45 #include "bus-objects.h"
47 #include "bus-container.h"
48 #include "bus-protocol.h"
49 #include "bus-track.h"
52 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
53 static int attach_io_events(sd_bus *b);
54 static void detach_io_events(sd_bus *b);
56 static void bus_close_fds(sd_bus *b) {
62 safe_close(b->input_fd);
64 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
65 safe_close(b->output_fd);
67 b->input_fd = b->output_fd = -1;
70 static void bus_reset_queues(sd_bus *b) {
73 while (b->rqueue_size > 0)
74 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
78 b->rqueue_allocated = 0;
80 while (b->wqueue_size > 0)
81 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
85 b->wqueue_allocated = 0;
88 static void bus_free(sd_bus *b) {
92 assert(!b->track_queue);
94 b->state = BUS_CLOSED;
96 sd_bus_detach_event(b);
98 while ((s = b->slots)) {
99 /* At this point only floating slots can still be
100 * around, because the non-floating ones keep a
101 * reference to the bus, and we thus couldn't be
102 * destructing right now... We forcibly disconnect the
103 * slots here, so that they still can be referenced by
104 * apps, but are dead. */
107 bus_slot_disconnect(s);
108 sd_bus_slot_unref(s);
111 if (b->default_bus_ptr)
112 *b->default_bus_ptr = NULL;
117 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
120 free(b->unique_name);
121 free(b->auth_buffer);
126 free(b->cgroup_root);
127 free(b->description);
130 strv_free(b->exec_argv);
132 close_many(b->fds, b->n_fds);
137 ordered_hashmap_free_free(b->reply_callbacks);
138 prioq_free(b->reply_callbacks_prioq);
140 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
141 bus_match_free(&b->match_callbacks);
143 hashmap_free_free(b->vtable_methods);
144 hashmap_free_free(b->vtable_properties);
146 assert(hashmap_isempty(b->nodes));
147 hashmap_free(b->nodes);
149 bus_kernel_flush_memfd(b);
151 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
156 _public_ int sd_bus_new(sd_bus **ret) {
159 assert_return(ret, -EINVAL);
165 r->n_ref = REFCNT_INIT;
166 r->input_fd = r->output_fd = -1;
167 r->message_version = 1;
168 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
169 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
170 r->attach_flags |= KDBUS_ATTACH_NAMES;
171 r->original_pid = getpid();
173 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
175 /* We guarantee that wqueue always has space for at least one
177 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
186 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
189 assert_return(bus, -EINVAL);
190 assert_return(bus->state == BUS_UNSET, -EPERM);
191 assert_return(address, -EINVAL);
192 assert_return(!bus_pid_changed(bus), -ECHILD);
204 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
205 assert_return(bus, -EINVAL);
206 assert_return(bus->state == BUS_UNSET, -EPERM);
207 assert_return(input_fd >= 0, -EINVAL);
208 assert_return(output_fd >= 0, -EINVAL);
209 assert_return(!bus_pid_changed(bus), -ECHILD);
211 bus->input_fd = input_fd;
212 bus->output_fd = output_fd;
216 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
219 assert_return(bus, -EINVAL);
220 assert_return(bus->state == BUS_UNSET, -EPERM);
221 assert_return(path, -EINVAL);
222 assert_return(!strv_isempty(argv), -EINVAL);
223 assert_return(!bus_pid_changed(bus), -ECHILD);
235 free(bus->exec_path);
236 strv_free(bus->exec_argv);
244 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
245 assert_return(bus, -EINVAL);
246 assert_return(bus->state == BUS_UNSET, -EPERM);
247 assert_return(!bus_pid_changed(bus), -ECHILD);
249 bus->bus_client = !!b;
253 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
254 assert_return(bus, -EINVAL);
255 assert_return(bus->state == BUS_UNSET, -EPERM);
256 assert_return(!bus_pid_changed(bus), -ECHILD);
258 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
262 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
263 assert_return(bus, -EINVAL);
264 assert_return(bus->state == BUS_UNSET, -EPERM);
265 assert_return(!bus_pid_changed(bus), -ECHILD);
267 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
271 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
273 assert_return(bus, -EINVAL);
274 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
275 assert_return(!bus_pid_changed(bus), -ECHILD);
277 new_flags = bus->attach_flags;
278 SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
280 if (bus->attach_flags == new_flags)
283 bus->attach_flags = new_flags;
284 if (bus->state != BUS_UNSET && bus->is_kernel)
285 bus_kernel_realize_attach_flags(bus);
290 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
293 assert_return(bus, -EINVAL);
294 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
295 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
296 assert_return(!bus_pid_changed(bus), -ECHILD);
299 bus->creds_mask |= mask;
301 bus->creds_mask &= ~mask;
303 /* The well knowns we need unconditionally, so that matches can work */
304 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
306 /* Make sure we don't lose the timestamp flag */
307 new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
308 if (bus->attach_flags == new_flags)
311 bus->attach_flags = new_flags;
312 if (bus->state != BUS_UNSET && bus->is_kernel)
313 bus_kernel_realize_attach_flags(bus);
318 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
319 assert_return(bus, -EINVAL);
320 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
321 assert_return(bus->state == BUS_UNSET, -EPERM);
322 assert_return(!bus_pid_changed(bus), -ECHILD);
324 bus->is_server = !!b;
325 bus->server_id = server_id;
329 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
330 assert_return(bus, -EINVAL);
331 assert_return(bus->state == BUS_UNSET, -EPERM);
332 assert_return(!bus_pid_changed(bus), -ECHILD);
334 bus->anonymous_auth = !!b;
338 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
339 assert_return(bus, -EINVAL);
340 assert_return(bus->state == BUS_UNSET, -EPERM);
341 assert_return(!bus_pid_changed(bus), -ECHILD);
347 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
348 assert_return(bus, -EINVAL);
349 assert_return(bus->state == BUS_UNSET, -EPERM);
350 assert_return(!bus_pid_changed(bus), -ECHILD);
352 return free_and_strdup(&bus->description, description);
355 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
356 assert_return(bus, -EINVAL);
357 assert_return(!bus_pid_changed(bus), -ECHILD);
359 bus->allow_interactive_authorization = !!b;
363 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
364 assert_return(bus, -EINVAL);
365 assert_return(!bus_pid_changed(bus), -ECHILD);
367 return bus->allow_interactive_authorization;
370 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
378 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
380 r = sd_bus_message_get_errno(reply);
384 r = sd_bus_message_read(reply, "s", &s);
388 if (!service_name_is_valid(s) || s[0] != ':')
391 bus->unique_name = strdup(s);
392 if (!bus->unique_name)
395 if (bus->state == BUS_HELLO)
396 bus->state = BUS_RUNNING;
401 static int bus_send_hello(sd_bus *bus) {
402 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
407 if (!bus->bus_client || bus->is_kernel)
410 r = sd_bus_message_new_method_call(
413 "org.freedesktop.DBus",
414 "/org/freedesktop/DBus",
415 "org.freedesktop.DBus",
420 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
423 int bus_start_running(sd_bus *bus) {
426 if (bus->bus_client && !bus->is_kernel) {
427 bus->state = BUS_HELLO;
431 bus->state = BUS_RUNNING;
435 static int parse_address_key(const char **p, const char *key, char **value) {
436 size_t l, n = 0, allocated = 0;
446 if (strncmp(*p, key, l) != 0)
459 while (*a != ';' && *a != ',' && *a != 0) {
477 c = (char) ((x << 4) | y);
484 if (!GREEDY_REALLOC(r, allocated, n + 2))
508 static void skip_address_key(const char **p) {
512 *p += strcspn(*p, ",");
518 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
519 _cleanup_free_ char *path = NULL, *abstract = NULL;
528 while (**p != 0 && **p != ';') {
529 r = parse_address_key(p, "guid", guid);
535 r = parse_address_key(p, "path", &path);
541 r = parse_address_key(p, "abstract", &abstract);
550 if (!path && !abstract)
553 if (path && abstract)
558 if (l > sizeof(b->sockaddr.un.sun_path))
561 b->sockaddr.un.sun_family = AF_UNIX;
562 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
563 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
564 } else if (abstract) {
565 l = strlen(abstract);
566 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
569 b->sockaddr.un.sun_family = AF_UNIX;
570 b->sockaddr.un.sun_path[0] = 0;
571 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
572 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
578 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
579 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
581 struct addrinfo *result, hints = {
582 .ai_socktype = SOCK_STREAM,
583 .ai_flags = AI_ADDRCONFIG,
591 while (**p != 0 && **p != ';') {
592 r = parse_address_key(p, "guid", guid);
598 r = parse_address_key(p, "host", &host);
604 r = parse_address_key(p, "port", &port);
610 r = parse_address_key(p, "family", &family);
623 if (streq(family, "ipv4"))
624 hints.ai_family = AF_INET;
625 else if (streq(family, "ipv6"))
626 hints.ai_family = AF_INET6;
631 r = getaddrinfo(host, port, &hints, &result);
635 return -EADDRNOTAVAIL;
637 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
638 b->sockaddr_size = result->ai_addrlen;
640 freeaddrinfo(result);
645 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
647 unsigned n_argv = 0, j;
649 size_t allocated = 0;
657 while (**p != 0 && **p != ';') {
658 r = parse_address_key(p, "guid", guid);
664 r = parse_address_key(p, "path", &path);
670 if (startswith(*p, "argv")) {
674 ul = strtoul(*p + 4, (char**) p, 10);
675 if (errno > 0 || **p != '=' || ul > 256) {
683 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
691 r = parse_address_key(p, NULL, argv + ul);
706 /* Make sure there are no holes in the array, with the
707 * exception of argv[0] */
708 for (j = 1; j < n_argv; j++)
714 if (argv && argv[0] == NULL) {
715 argv[0] = strdup(path);
727 for (j = 0; j < n_argv; j++)
735 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
736 _cleanup_free_ char *path = NULL;
744 while (**p != 0 && **p != ';') {
745 r = parse_address_key(p, "guid", guid);
751 r = parse_address_key(p, "path", &path);
770 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
771 _cleanup_free_ char *machine = NULL, *pid = NULL;
779 while (**p != 0 && **p != ';') {
780 r = parse_address_key(p, "guid", guid);
786 r = parse_address_key(p, "machine", &machine);
792 r = parse_address_key(p, "pid", &pid);
801 if (!machine == !pid)
805 if (!machine_name_is_valid(machine))
809 b->machine = machine;
817 r = parse_pid(pid, &b->nspid);
823 b->sockaddr.un.sun_family = AF_UNIX;
824 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
825 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
830 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
831 _cleanup_free_ char *machine = NULL, *pid = NULL;
839 while (**p != 0 && **p != ';') {
840 r = parse_address_key(p, "guid", guid);
846 r = parse_address_key(p, "machine", &machine);
852 r = parse_address_key(p, "pid", &pid);
861 if (!machine == !pid)
865 if (!machine_name_is_valid(machine))
869 b->machine = machine;
877 r = parse_pid(pid, &b->nspid);
884 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
891 static void bus_reset_parsed_address(sd_bus *b) {
895 b->sockaddr_size = 0;
896 strv_free(b->exec_argv);
900 b->server_id = SD_ID128_NULL;
908 static int bus_parse_next_address(sd_bus *b) {
909 _cleanup_free_ char *guid = NULL;
917 if (b->address[b->address_index] == 0)
920 bus_reset_parsed_address(b);
922 a = b->address + b->address_index;
931 if (startswith(a, "unix:")) {
934 r = parse_unix_address(b, &a, &guid);
939 } else if (startswith(a, "tcp:")) {
942 r = parse_tcp_address(b, &a, &guid);
948 } else if (startswith(a, "unixexec:")) {
951 r = parse_exec_address(b, &a, &guid);
957 } else if (startswith(a, "kernel:")) {
960 r = parse_kernel_address(b, &a, &guid);
965 } else if (startswith(a, "x-machine-unix:")) {
968 r = parse_container_unix_address(b, &a, &guid);
973 } else if (startswith(a, "x-machine-kernel:")) {
976 r = parse_container_kernel_address(b, &a, &guid);
989 r = sd_id128_from_string(guid, &b->server_id);
994 b->address_index = a - b->address;
998 static int bus_start_address(sd_bus *b) {
1004 bool skipped = false;
1009 r = bus_socket_exec(b);
1010 else if ((b->nspid > 0 || b->machine) && b->kernel)
1011 r = bus_container_connect_kernel(b);
1012 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1013 r = bus_container_connect_socket(b);
1015 r = bus_kernel_connect(b);
1016 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1017 r = bus_socket_connect(b);
1023 r = attach_io_events(b);
1028 b->last_connect_error = -r;
1031 r = bus_parse_next_address(b);
1035 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1039 int bus_next_address(sd_bus *b) {
1042 bus_reset_parsed_address(b);
1043 return bus_start_address(b);
1046 static int bus_start_fd(sd_bus *b) {
1051 assert(b->input_fd >= 0);
1052 assert(b->output_fd >= 0);
1054 r = fd_nonblock(b->input_fd, true);
1058 r = fd_cloexec(b->input_fd, true);
1062 if (b->input_fd != b->output_fd) {
1063 r = fd_nonblock(b->output_fd, true);
1067 r = fd_cloexec(b->output_fd, true);
1072 if (fstat(b->input_fd, &st) < 0)
1075 if (S_ISCHR(b->input_fd))
1076 return bus_kernel_take_fd(b);
1078 return bus_socket_take_fd(b);
1081 _public_ int sd_bus_start(sd_bus *bus) {
1084 assert_return(bus, -EINVAL);
1085 assert_return(bus->state == BUS_UNSET, -EPERM);
1086 assert_return(!bus_pid_changed(bus), -ECHILD);
1088 bus->state = BUS_OPENING;
1090 if (bus->is_server && bus->bus_client)
1093 if (bus->input_fd >= 0)
1094 r = bus_start_fd(bus);
1095 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1096 r = bus_start_address(bus);
1105 return bus_send_hello(bus);
1108 _public_ int sd_bus_open(sd_bus **ret) {
1113 assert_return(ret, -EINVAL);
1115 /* Let's connect to the starter bus if it is set, and
1116 * otherwise to the bus that is appropropriate for the scope
1117 * we are running in */
1119 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1121 if (streq(e, "system"))
1122 return sd_bus_open_system(ret);
1123 else if (STR_IN_SET(e, "session", "user"))
1124 return sd_bus_open_user(ret);
1127 e = secure_getenv("DBUS_STARTER_ADDRESS");
1129 return sd_bus_open_system(ret);
1136 r = sd_bus_set_address(b, e);
1140 b->bus_client = true;
1142 /* We don't know whether the bus is trusted or not, so better
1143 * be safe, and authenticate everything */
1145 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1146 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1148 r = sd_bus_start(b);
1160 int bus_set_address_system(sd_bus *b) {
1164 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1166 return sd_bus_set_address(b, e);
1168 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1171 _public_ int sd_bus_open_system(sd_bus **ret) {
1175 assert_return(ret, -EINVAL);
1181 r = bus_set_address_system(b);
1185 b->bus_client = true;
1186 b->is_system = true;
1188 /* Let's do per-method access control on the system bus. We
1189 * need the caller's UID and capability set for that. */
1191 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1192 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1194 r = sd_bus_start(b);
1206 int bus_set_address_user(sd_bus *b) {
1211 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1213 return sd_bus_set_address(b, e);
1215 e = secure_getenv("XDG_RUNTIME_DIR");
1217 _cleanup_free_ char *ee = NULL;
1219 ee = bus_address_escape(e);
1224 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1226 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1230 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1232 return -ECONNREFUSED;
1242 _public_ int sd_bus_open_user(sd_bus **ret) {
1246 assert_return(ret, -EINVAL);
1252 r = bus_set_address_user(b);
1256 b->bus_client = true;
1259 /* We don't do any per-method access control on the user
1263 r = sd_bus_start(b);
1275 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1276 _cleanup_free_ char *e = NULL;
1277 char *m = NULL, *c = NULL;
1282 /* Let's see if we shall enter some container */
1283 m = strchr(host, ':');
1287 /* Let's make sure this is not a port of some kind,
1288 * and is a valid machine name. */
1289 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1292 /* Cut out the host part */
1293 t = strndupa(host, m - host - 1);
1294 e = bus_address_escape(t);
1298 c = strjoina(",argv4=--machine=", m);
1303 e = bus_address_escape(host);
1308 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1315 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1319 assert_return(host, -EINVAL);
1320 assert_return(ret, -EINVAL);
1322 r = sd_bus_new(&bus);
1326 r = bus_set_address_system_remote(bus, host);
1330 bus->bus_client = true;
1331 bus->trusted = false;
1332 bus->is_system = true;
1334 r = sd_bus_start(bus);
1346 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1347 _cleanup_free_ char *e = NULL;
1352 e = bus_address_escape(machine);
1357 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1359 b->address = strjoin("x-machine-unix:machine=", e, NULL);
1367 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1371 assert_return(machine, -EINVAL);
1372 assert_return(ret, -EINVAL);
1373 assert_return(machine_name_is_valid(machine), -EINVAL);
1375 r = sd_bus_new(&bus);
1379 r = bus_set_address_system_machine(bus, machine);
1383 bus->bus_client = true;
1384 bus->trusted = false;
1385 bus->is_system = true;
1387 r = sd_bus_start(bus);
1399 _public_ void sd_bus_close(sd_bus *bus) {
1403 if (bus->state == BUS_CLOSED)
1405 if (bus_pid_changed(bus))
1408 bus->state = BUS_CLOSED;
1410 sd_bus_detach_event(bus);
1412 /* Drop all queued messages so that they drop references to
1413 * the bus object and the bus may be freed */
1414 bus_reset_queues(bus);
1416 if (!bus->is_kernel)
1419 /* We'll leave the fd open in case this is a kernel bus, since
1420 * there might still be memblocks around that reference this
1421 * bus, and they might need to invoke the KDBUS_CMD_FREE
1422 * ioctl on the fd when they are freed. */
1425 static void bus_enter_closing(sd_bus *bus) {
1428 if (bus->state != BUS_OPENING &&
1429 bus->state != BUS_AUTHENTICATING &&
1430 bus->state != BUS_HELLO &&
1431 bus->state != BUS_RUNNING)
1434 bus->state = BUS_CLOSING;
1437 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1438 assert_return(bus, NULL);
1440 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1445 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1451 i = REFCNT_DEC(bus->n_ref);
1459 _public_ int sd_bus_is_open(sd_bus *bus) {
1461 assert_return(bus, -EINVAL);
1462 assert_return(!bus_pid_changed(bus), -ECHILD);
1464 return BUS_IS_OPEN(bus->state);
1467 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1470 assert_return(bus, -EINVAL);
1471 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1472 assert_return(!bus_pid_changed(bus), -ECHILD);
1474 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1477 if (type == SD_BUS_TYPE_UNIX_FD) {
1478 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1481 r = bus_ensure_running(bus);
1485 return bus->can_fds;
1488 return bus_type_is_valid(type);
1491 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1494 assert_return(bus, -EINVAL);
1495 assert_return(id, -EINVAL);
1496 assert_return(!bus_pid_changed(bus), -ECHILD);
1498 r = bus_ensure_running(bus);
1502 *id = bus->server_id;
1506 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1511 /* If we copy the same message to multiple
1512 * destinations, avoid using the same cookie
1514 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1519 timeout = BUS_DEFAULT_TIMEOUT;
1521 return bus_message_seal(m, ++b->cookie, timeout);
1524 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1525 bool remarshal = false;
1529 /* wrong packet version */
1530 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1533 /* wrong packet endianness */
1534 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1537 /* TODO: kdbus-messages received from the kernel contain data which is
1538 * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1539 * force remarshaling of the message. Technically, we could just
1540 * recreate the kdbus message, but that is non-trivial as other parts of
1541 * the message refer to m->kdbus already. This should be fixed! */
1542 if ((*m)->kdbus && (*m)->release_kdbus)
1545 return remarshal ? bus_message_remarshal(b, m) : 0;
1548 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1552 /* Fake some timestamps, if they were requested, and not
1553 * already initialized */
1554 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1555 if (m->realtime <= 0)
1556 m->realtime = now(CLOCK_REALTIME);
1558 if (m->monotonic <= 0)
1559 m->monotonic = now(CLOCK_MONOTONIC);
1562 /* The bus specification says the serial number cannot be 0,
1563 * hence let's fill something in for synthetic messages. Since
1564 * synthetic messages might have a fake sender and we don't
1565 * want to interfere with the real sender's serial numbers we
1566 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1567 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1568 * even though kdbus can do 64bit. */
1569 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1572 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1579 r = bus_kernel_write_message(bus, m, hint_sync_call);
1581 r = bus_socket_write_message(bus, m, idx);
1586 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1587 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1588 bus_message_type_to_string(m->header->type),
1589 strna(sd_bus_message_get_sender(m)),
1590 strna(sd_bus_message_get_destination(m)),
1591 strna(sd_bus_message_get_path(m)),
1592 strna(sd_bus_message_get_interface(m)),
1593 strna(sd_bus_message_get_member(m)),
1594 BUS_MESSAGE_COOKIE(m),
1596 strna(m->error.message));
1601 static int dispatch_wqueue(sd_bus *bus) {
1605 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1607 while (bus->wqueue_size > 0) {
1609 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1613 /* Didn't do anything this time */
1615 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1616 /* Fully written. Let's drop the entry from
1619 * This isn't particularly optimized, but
1620 * well, this is supposed to be our worst-case
1621 * buffer only, and the socket buffer is
1622 * supposed to be our primary buffer, and if
1623 * it got full, then all bets are off
1626 bus->wqueue_size --;
1627 sd_bus_message_unref(bus->wqueue[0]);
1628 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1638 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1642 return bus_kernel_read_message(bus, hint_priority, priority);
1644 return bus_socket_read_message(bus);
1647 int bus_rqueue_make_room(sd_bus *bus) {
1650 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1653 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1659 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1664 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1666 /* Note that the priority logic is only available on kdbus,
1667 * where the rqueue is unused. We check the rqueue here
1668 * anyway, because it's simple... */
1671 if (bus->rqueue_size > 0) {
1672 /* Dispatch a queued message */
1674 *m = bus->rqueue[0];
1675 bus->rqueue_size --;
1676 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1680 /* Try to read a new message */
1681 r = bus_read_message(bus, hint_priority, priority);
1691 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1692 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1695 assert_return(m, -EINVAL);
1700 assert_return(!bus_pid_changed(bus), -ECHILD);
1701 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1703 if (!BUS_IS_OPEN(bus->state))
1707 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1714 /* If the cookie number isn't kept, then we know that no reply
1716 if (!cookie && !m->sealed)
1717 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1719 r = bus_seal_message(bus, m, 0);
1723 /* Remarshall if we have to. This will possibly unref the
1724 * message and place a replacement in m */
1725 r = bus_remarshal_message(bus, &m);
1729 /* If this is a reply and no reply was requested, then let's
1730 * suppress this, if we can */
1734 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1737 r = bus_write_message(bus, m, hint_sync_call, &idx);
1739 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1740 bus_enter_closing(bus);
1747 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1748 /* Wasn't fully written. So let's remember how
1749 * much was written. Note that the first entry
1750 * of the wqueue array is always allocated so
1751 * that we always can remember how much was
1753 bus->wqueue[0] = sd_bus_message_ref(m);
1754 bus->wqueue_size = 1;
1759 /* Just append it to the queue. */
1761 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1764 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1767 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1772 *cookie = BUS_MESSAGE_COOKIE(m);
1777 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1778 return bus_send_internal(bus, m, cookie, false);
1781 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1784 assert_return(m, -EINVAL);
1789 assert_return(!bus_pid_changed(bus), -ECHILD);
1791 if (!BUS_IS_OPEN(bus->state))
1794 if (!streq_ptr(m->destination, destination)) {
1799 r = sd_bus_message_set_destination(m, destination);
1804 return sd_bus_send(bus, m, cookie);
1807 static usec_t calc_elapse(uint64_t usec) {
1808 if (usec == (uint64_t) -1)
1811 return now(CLOCK_MONOTONIC) + usec;
1814 static int timeout_compare(const void *a, const void *b) {
1815 const struct reply_callback *x = a, *y = b;
1817 if (x->timeout != 0 && y->timeout == 0)
1820 if (x->timeout == 0 && y->timeout != 0)
1823 if (x->timeout < y->timeout)
1826 if (x->timeout > y->timeout)
1832 _public_ int sd_bus_call_async(
1836 sd_bus_message_handler_t callback,
1840 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1841 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1844 assert_return(m, -EINVAL);
1845 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1846 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1847 assert_return(callback, -EINVAL);
1852 assert_return(!bus_pid_changed(bus), -ECHILD);
1853 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1855 if (!BUS_IS_OPEN(bus->state))
1858 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1862 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1866 r = bus_seal_message(bus, m, usec);
1870 r = bus_remarshal_message(bus, &m);
1874 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1878 s->reply_callback.callback = callback;
1880 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1881 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1883 s->reply_callback.cookie = 0;
1887 s->reply_callback.timeout = calc_elapse(m->timeout);
1888 if (s->reply_callback.timeout != 0) {
1889 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1891 s->reply_callback.timeout = 0;
1896 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1907 int bus_ensure_running(sd_bus *bus) {
1912 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1914 if (bus->state == BUS_RUNNING)
1918 r = sd_bus_process(bus, NULL);
1921 if (bus->state == BUS_RUNNING)
1926 r = sd_bus_wait(bus, (uint64_t) -1);
1932 _public_ int sd_bus_call(
1936 sd_bus_error *error,
1937 sd_bus_message **reply) {
1939 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1945 assert_return(m, -EINVAL);
1946 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1947 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1948 assert_return(!bus_error_is_dirty(error), -EINVAL);
1953 assert_return(!bus_pid_changed(bus), -ECHILD);
1954 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1956 if (!BUS_IS_OPEN(bus->state))
1959 r = bus_ensure_running(bus);
1963 i = bus->rqueue_size;
1965 r = bus_seal_message(bus, m, usec);
1969 r = bus_remarshal_message(bus, &m);
1973 r = bus_send_internal(bus, m, &cookie, true);
1977 timeout = calc_elapse(m->timeout);
1982 while (i < bus->rqueue_size) {
1983 sd_bus_message *incoming = NULL;
1985 incoming = bus->rqueue[i];
1987 if (incoming->reply_cookie == cookie) {
1988 /* Found a match! */
1990 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1993 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1995 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1999 sd_bus_message_unref(incoming);
2004 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2006 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
2007 r = sd_bus_error_copy(error, &incoming->error);
2011 sd_bus_message_unref(incoming);
2014 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2017 streq(bus->unique_name, incoming->sender)) {
2019 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2022 /* Our own message? Somebody is trying
2023 * to send its own client a message,
2024 * let's not dead-lock, let's fail
2027 sd_bus_message_unref(incoming);
2031 /* Try to read more, right-away */
2035 r = bus_read_message(bus, false, 0);
2037 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2038 bus_enter_closing(bus);
2050 n = now(CLOCK_MONOTONIC);
2056 left = (uint64_t) -1;
2058 r = bus_poll(bus, true, left);
2064 r = dispatch_wqueue(bus);
2066 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2067 bus_enter_closing(bus);
2076 _public_ int sd_bus_get_fd(sd_bus *bus) {
2078 assert_return(bus, -EINVAL);
2079 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2080 assert_return(!bus_pid_changed(bus), -ECHILD);
2082 return bus->input_fd;
2085 _public_ int sd_bus_get_events(sd_bus *bus) {
2088 assert_return(bus, -EINVAL);
2089 assert_return(!bus_pid_changed(bus), -ECHILD);
2091 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2094 if (bus->state == BUS_OPENING)
2096 else if (bus->state == BUS_AUTHENTICATING) {
2098 if (bus_socket_auth_needs_write(bus))
2103 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2104 if (bus->rqueue_size <= 0)
2106 if (bus->wqueue_size > 0)
2113 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2114 struct reply_callback *c;
2116 assert_return(bus, -EINVAL);
2117 assert_return(timeout_usec, -EINVAL);
2118 assert_return(!bus_pid_changed(bus), -ECHILD);
2120 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2123 if (bus->track_queue) {
2128 if (bus->state == BUS_CLOSING) {
2133 if (bus->state == BUS_AUTHENTICATING) {
2134 *timeout_usec = bus->auth_timeout;
2138 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2139 *timeout_usec = (uint64_t) -1;
2143 if (bus->rqueue_size > 0) {
2148 c = prioq_peek(bus->reply_callbacks_prioq);
2150 *timeout_usec = (uint64_t) -1;
2154 if (c->timeout == 0) {
2155 *timeout_usec = (uint64_t) -1;
2159 *timeout_usec = c->timeout;
2163 static int process_timeout(sd_bus *bus) {
2164 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2165 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2166 struct reply_callback *c;
2173 c = prioq_peek(bus->reply_callbacks_prioq);
2177 n = now(CLOCK_MONOTONIC);
2181 r = bus_message_new_synthetic_error(
2184 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2189 r = bus_seal_synthetic_message(bus, m);
2193 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2196 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2199 slot = container_of(c, sd_bus_slot, reply_callback);
2201 bus->iteration_counter ++;
2203 bus->current_message = m;
2204 bus->current_slot = sd_bus_slot_ref(slot);
2205 bus->current_handler = c->callback;
2206 bus->current_userdata = slot->userdata;
2207 r = c->callback(m, slot->userdata, &error_buffer);
2208 bus->current_userdata = NULL;
2209 bus->current_handler = NULL;
2210 bus->current_slot = NULL;
2211 bus->current_message = NULL;
2213 if (slot->floating) {
2214 bus_slot_disconnect(slot);
2215 sd_bus_slot_unref(slot);
2218 sd_bus_slot_unref(slot);
2220 return bus_maybe_reply_error(m, r, &error_buffer);
2223 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2227 if (bus->state != BUS_HELLO)
2230 /* Let's make sure the first message on the bus is the HELLO
2231 * reply. But note that we don't actually parse the message
2232 * here (we leave that to the usual handling), we just verify
2233 * we don't let any earlier msg through. */
2235 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2236 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2239 if (m->reply_cookie != 1)
2245 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2246 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2247 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2248 struct reply_callback *c;
2255 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2256 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2259 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2262 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2265 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2271 slot = container_of(c, sd_bus_slot, reply_callback);
2273 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2275 /* If the reply contained a file descriptor which we
2276 * didn't want we pass an error instead. */
2278 r = bus_message_new_synthetic_error(
2281 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2286 /* Copy over original timestamp */
2287 synthetic_reply->realtime = m->realtime;
2288 synthetic_reply->monotonic = m->monotonic;
2289 synthetic_reply->seqnum = m->seqnum;
2291 r = bus_seal_synthetic_message(bus, synthetic_reply);
2295 m = synthetic_reply;
2297 r = sd_bus_message_rewind(m, true);
2302 if (c->timeout != 0) {
2303 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2307 bus->current_slot = sd_bus_slot_ref(slot);
2308 bus->current_handler = c->callback;
2309 bus->current_userdata = slot->userdata;
2310 r = c->callback(m, slot->userdata, &error_buffer);
2311 bus->current_userdata = NULL;
2312 bus->current_handler = NULL;
2313 bus->current_slot = NULL;
2315 if (slot->floating) {
2316 bus_slot_disconnect(slot);
2317 sd_bus_slot_unref(slot);
2320 sd_bus_slot_unref(slot);
2322 return bus_maybe_reply_error(m, r, &error_buffer);
2325 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2326 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2327 struct filter_callback *l;
2334 bus->filter_callbacks_modified = false;
2336 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2339 if (bus->filter_callbacks_modified)
2342 /* Don't run this more than once per iteration */
2343 if (l->last_iteration == bus->iteration_counter)
2346 l->last_iteration = bus->iteration_counter;
2348 r = sd_bus_message_rewind(m, true);
2352 slot = container_of(l, sd_bus_slot, filter_callback);
2354 bus->current_slot = sd_bus_slot_ref(slot);
2355 bus->current_handler = l->callback;
2356 bus->current_userdata = slot->userdata;
2357 r = l->callback(m, slot->userdata, &error_buffer);
2358 bus->current_userdata = NULL;
2359 bus->current_handler = NULL;
2360 bus->current_slot = sd_bus_slot_unref(slot);
2362 r = bus_maybe_reply_error(m, r, &error_buffer);
2368 } while (bus->filter_callbacks_modified);
2373 static int process_match(sd_bus *bus, sd_bus_message *m) {
2380 bus->match_callbacks_modified = false;
2382 r = bus_match_run(bus, &bus->match_callbacks, m);
2386 } while (bus->match_callbacks_modified);
2391 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2392 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2398 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2401 if (bus->manual_peer_interface)
2404 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2407 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2410 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2413 if (streq_ptr(m->member, "Ping"))
2414 r = sd_bus_message_new_method_return(m, &reply);
2415 else if (streq_ptr(m->member, "GetMachineId")) {
2419 r = sd_id128_get_machine(&id);
2423 r = sd_bus_message_new_method_return(m, &reply);
2427 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2429 r = sd_bus_message_new_method_errorf(
2431 SD_BUS_ERROR_UNKNOWN_METHOD,
2432 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2438 r = sd_bus_send(bus, reply, NULL);
2445 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2449 /* If we got a message with a file descriptor which we didn't
2450 * want to accept, then let's drop it. How can this even
2451 * happen? For example, when the kernel queues a message into
2452 * an activatable names's queue which allows fds, and then is
2453 * delivered to us later even though we ourselves did not
2456 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2462 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2465 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2466 return 1; /* just eat it up */
2468 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2471 static int process_message(sd_bus *bus, sd_bus_message *m) {
2477 bus->current_message = m;
2478 bus->iteration_counter++;
2480 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2481 bus_message_type_to_string(m->header->type),
2482 strna(sd_bus_message_get_sender(m)),
2483 strna(sd_bus_message_get_destination(m)),
2484 strna(sd_bus_message_get_path(m)),
2485 strna(sd_bus_message_get_interface(m)),
2486 strna(sd_bus_message_get_member(m)),
2487 BUS_MESSAGE_COOKIE(m),
2489 strna(m->error.message));
2491 r = process_hello(bus, m);
2495 r = process_reply(bus, m);
2499 r = process_fd_check(bus, m);
2503 r = process_filter(bus, m);
2507 r = process_match(bus, m);
2511 r = process_builtin(bus, m);
2515 r = bus_process_object(bus, m);
2518 bus->current_message = NULL;
2522 static int dispatch_track(sd_bus *bus) {
2525 if (!bus->track_queue)
2528 bus_track_dispatch(bus->track_queue);
2532 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2533 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2537 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2539 r = process_timeout(bus);
2543 r = dispatch_wqueue(bus);
2547 r = dispatch_track(bus);
2551 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2557 r = process_message(bus, m);
2562 r = sd_bus_message_rewind(m, true);
2571 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2573 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2574 strna(sd_bus_message_get_sender(m)),
2575 strna(sd_bus_message_get_path(m)),
2576 strna(sd_bus_message_get_interface(m)),
2577 strna(sd_bus_message_get_member(m)));
2579 r = sd_bus_reply_method_errorf(
2581 SD_BUS_ERROR_UNKNOWN_OBJECT,
2582 "Unknown object '%s'.", m->path);
2596 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2597 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2598 struct reply_callback *c;
2602 assert(bus->state == BUS_CLOSING);
2604 c = ordered_hashmap_first(bus->reply_callbacks);
2606 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2609 /* First, fail all outstanding method calls */
2610 r = bus_message_new_synthetic_error(
2613 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2618 r = bus_seal_synthetic_message(bus, m);
2622 if (c->timeout != 0) {
2623 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2627 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2630 slot = container_of(c, sd_bus_slot, reply_callback);
2632 bus->iteration_counter++;
2634 bus->current_message = m;
2635 bus->current_slot = sd_bus_slot_ref(slot);
2636 bus->current_handler = c->callback;
2637 bus->current_userdata = slot->userdata;
2638 r = c->callback(m, slot->userdata, &error_buffer);
2639 bus->current_userdata = NULL;
2640 bus->current_handler = NULL;
2641 bus->current_slot = NULL;
2642 bus->current_message = NULL;
2644 if (slot->floating) {
2645 bus_slot_disconnect(slot);
2646 sd_bus_slot_unref(slot);
2649 sd_bus_slot_unref(slot);
2651 return bus_maybe_reply_error(m, r, &error_buffer);
2654 /* Then, synthesize a Disconnected message */
2655 r = sd_bus_message_new_signal(
2658 "/org/freedesktop/DBus/Local",
2659 "org.freedesktop.DBus.Local",
2664 bus_message_set_sender_local(bus, m);
2666 r = bus_seal_synthetic_message(bus, m);
2672 bus->current_message = m;
2673 bus->iteration_counter++;
2675 r = process_filter(bus, m);
2679 r = process_match(bus, m);
2691 bus->current_message = NULL;
2696 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2697 BUS_DONT_DESTROY(bus);
2700 /* Returns 0 when we didn't do anything. This should cause the
2701 * caller to invoke sd_bus_wait() before returning the next
2702 * time. Returns > 0 when we did something, which possibly
2703 * means *ret is filled in with an unprocessed message. */
2705 assert_return(bus, -EINVAL);
2706 assert_return(!bus_pid_changed(bus), -ECHILD);
2708 /* We don't allow recursively invoking sd_bus_process(). */
2709 assert_return(!bus->current_message, -EBUSY);
2710 assert(!bus->current_slot);
2712 switch (bus->state) {
2721 r = bus_socket_process_opening(bus);
2722 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2723 bus_enter_closing(bus);
2731 case BUS_AUTHENTICATING:
2732 r = bus_socket_process_authenticating(bus);
2733 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2734 bus_enter_closing(bus);
2746 r = process_running(bus, hint_priority, priority, ret);
2747 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2748 bus_enter_closing(bus);
2758 return process_closing(bus, ret);
2761 assert_not_reached("Unknown state");
2764 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2765 return bus_process_internal(bus, false, 0, ret);
2768 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2769 return bus_process_internal(bus, true, priority, ret);
2772 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2773 struct pollfd p[2] = {};
2776 usec_t m = USEC_INFINITY;
2780 if (bus->state == BUS_CLOSING)
2783 if (!BUS_IS_OPEN(bus->state))
2786 e = sd_bus_get_events(bus);
2791 /* The caller really needs some more data, he doesn't
2792 * care about what's already read, or any timeouts
2793 * except its own. */
2797 /* The caller wants to process if there's something to
2798 * process, but doesn't care otherwise */
2800 r = sd_bus_get_timeout(bus, &until);
2805 nw = now(CLOCK_MONOTONIC);
2806 m = until > nw ? until - nw : 0;
2810 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2813 p[0].fd = bus->input_fd;
2814 if (bus->output_fd == bus->input_fd) {
2818 p[0].events = e & POLLIN;
2819 p[1].fd = bus->output_fd;
2820 p[1].events = e & POLLOUT;
2824 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2828 return r > 0 ? 1 : 0;
2831 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2833 assert_return(bus, -EINVAL);
2834 assert_return(!bus_pid_changed(bus), -ECHILD);
2836 if (bus->state == BUS_CLOSING)
2839 if (!BUS_IS_OPEN(bus->state))
2842 if (bus->rqueue_size > 0)
2845 return bus_poll(bus, false, timeout_usec);
2848 _public_ int sd_bus_flush(sd_bus *bus) {
2851 assert_return(bus, -EINVAL);
2852 assert_return(!bus_pid_changed(bus), -ECHILD);
2854 if (bus->state == BUS_CLOSING)
2857 if (!BUS_IS_OPEN(bus->state))
2860 r = bus_ensure_running(bus);
2864 if (bus->wqueue_size <= 0)
2868 r = dispatch_wqueue(bus);
2870 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2871 bus_enter_closing(bus);
2878 if (bus->wqueue_size <= 0)
2881 r = bus_poll(bus, false, (uint64_t) -1);
2887 _public_ int sd_bus_add_filter(
2890 sd_bus_message_handler_t callback,
2895 assert_return(bus, -EINVAL);
2896 assert_return(callback, -EINVAL);
2897 assert_return(!bus_pid_changed(bus), -ECHILD);
2899 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2903 s->filter_callback.callback = callback;
2905 bus->filter_callbacks_modified = true;
2906 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2914 _public_ int sd_bus_add_match(
2918 sd_bus_message_handler_t callback,
2921 struct bus_match_component *components = NULL;
2922 unsigned n_components = 0;
2923 sd_bus_slot *s = NULL;
2926 assert_return(bus, -EINVAL);
2927 assert_return(match, -EINVAL);
2928 assert_return(!bus_pid_changed(bus), -ECHILD);
2930 r = bus_match_parse(match, &components, &n_components);
2934 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2940 s->match_callback.callback = callback;
2941 s->match_callback.cookie = ++bus->match_cookie;
2943 if (bus->bus_client) {
2945 if (!bus->is_kernel) {
2946 /* When this is not a kernel transport, we
2947 * store the original match string, so that we
2948 * can use it to remove the match again */
2950 s->match_callback.match_string = strdup(match);
2951 if (!s->match_callback.match_string) {
2957 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2962 bus->match_callbacks_modified = true;
2963 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2972 bus_match_parse_free(components, n_components);
2973 sd_bus_slot_unref(s);
2978 int bus_remove_match_by_string(
2981 sd_bus_message_handler_t callback,
2984 struct bus_match_component *components = NULL;
2985 unsigned n_components = 0;
2986 struct match_callback *c;
2989 assert_return(bus, -EINVAL);
2990 assert_return(match, -EINVAL);
2991 assert_return(!bus_pid_changed(bus), -ECHILD);
2993 r = bus_match_parse(match, &components, &n_components);
2997 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3001 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3004 bus_match_parse_free(components, n_components);
3009 bool bus_pid_changed(sd_bus *bus) {
3012 /* We don't support people creating a bus connection and
3013 * keeping it around over a fork(). Let's complain. */
3015 return bus->original_pid != getpid();
3018 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3019 sd_bus *bus = userdata;
3024 r = sd_bus_process(bus, NULL);
3031 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3032 sd_bus *bus = userdata;
3037 r = sd_bus_process(bus, NULL);
3044 static int prepare_callback(sd_event_source *s, void *userdata) {
3045 sd_bus *bus = userdata;
3052 e = sd_bus_get_events(bus);
3056 if (bus->output_fd != bus->input_fd) {
3058 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3062 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3066 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3071 r = sd_bus_get_timeout(bus, &until);
3077 j = sd_event_source_set_time(bus->time_event_source, until);
3082 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3089 static int quit_callback(sd_event_source *event, void *userdata) {
3090 sd_bus *bus = userdata;
3100 static int attach_io_events(sd_bus *bus) {
3105 if (bus->input_fd < 0)
3111 if (!bus->input_io_event_source) {
3112 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3116 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3120 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3124 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3126 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3131 if (bus->output_fd != bus->input_fd) {
3132 assert(bus->output_fd >= 0);
3134 if (!bus->output_io_event_source) {
3135 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3139 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3143 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3145 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3154 static void detach_io_events(sd_bus *bus) {
3157 if (bus->input_io_event_source) {
3158 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3159 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3162 if (bus->output_io_event_source) {
3163 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3164 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3168 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3171 assert_return(bus, -EINVAL);
3172 assert_return(!bus->event, -EBUSY);
3174 assert(!bus->input_io_event_source);
3175 assert(!bus->output_io_event_source);
3176 assert(!bus->time_event_source);
3179 bus->event = sd_event_ref(event);
3181 r = sd_event_default(&bus->event);
3186 bus->event_priority = priority;
3188 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3192 r = sd_event_source_set_priority(bus->time_event_source, priority);
3196 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3200 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3204 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3208 r = attach_io_events(bus);
3215 sd_bus_detach_event(bus);
3219 _public_ int sd_bus_detach_event(sd_bus *bus) {
3220 assert_return(bus, -EINVAL);
3225 detach_io_events(bus);
3227 if (bus->time_event_source) {
3228 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3229 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3232 if (bus->quit_event_source) {
3233 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3234 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3237 bus->event = sd_event_unref(bus->event);
3241 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3242 assert_return(bus, NULL);
3247 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3248 assert_return(bus, NULL);
3250 return bus->current_message;
3253 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3254 assert_return(bus, NULL);
3256 return bus->current_slot;
3259 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3260 assert_return(bus, NULL);
3262 return bus->current_handler;
3265 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3266 assert_return(bus, NULL);
3268 return bus->current_userdata;
3271 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3276 assert(default_bus);
3279 return !!*default_bus;
3282 *ret = sd_bus_ref(*default_bus);
3290 b->default_bus_ptr = default_bus;
3298 _public_ int sd_bus_default_system(sd_bus **ret) {
3299 static thread_local sd_bus *default_system_bus = NULL;
3301 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3304 _public_ int sd_bus_default_user(sd_bus **ret) {
3305 static thread_local sd_bus *default_user_bus = NULL;
3307 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3310 _public_ int sd_bus_default(sd_bus **ret) {
3314 /* Let's try our best to reuse another cached connection. If
3315 * the starter bus type is set, connect via our normal
3316 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3317 * we can share the connection with the user/system default
3320 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3322 if (streq(e, "system"))
3323 return sd_bus_default_system(ret);
3324 else if (STR_IN_SET(e, "user", "session"))
3325 return sd_bus_default_user(ret);
3328 /* No type is specified, so we have not other option than to
3329 * use the starter address if it is set. */
3331 e = secure_getenv("DBUS_STARTER_ADDRESS");
3333 static thread_local sd_bus *default_starter_bus = NULL;
3335 return bus_default(sd_bus_open, &default_starter_bus, ret);
3338 /* Finally, if nothing is set use the cached connection for
3339 * the right scope */
3341 return sd_bus_default_system(ret);
3344 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3345 assert_return(b, -EINVAL);
3346 assert_return(tid, -EINVAL);
3347 assert_return(!bus_pid_changed(b), -ECHILD);
3355 return sd_event_get_tid(b->event, tid);
3360 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3361 _cleanup_free_ char *e = NULL;
3364 assert_return(object_path_is_valid(prefix), -EINVAL);
3365 assert_return(external_id, -EINVAL);
3366 assert_return(ret_path, -EINVAL);
3368 e = bus_label_escape(external_id);
3372 ret = strjoin(prefix, "/", e, NULL);
3380 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3384 assert_return(object_path_is_valid(path), -EINVAL);
3385 assert_return(object_path_is_valid(prefix), -EINVAL);
3386 assert_return(external_id, -EINVAL);
3388 e = object_path_startswith(path, prefix);
3390 *external_id = NULL;
3394 ret = bus_label_unescape(e);
3402 _public_ int sd_bus_try_close(sd_bus *bus) {
3405 assert_return(bus, -EINVAL);
3406 assert_return(!bus_pid_changed(bus), -ECHILD);
3408 if (!bus->is_kernel)
3411 if (!BUS_IS_OPEN(bus->state))
3414 if (bus->rqueue_size > 0)
3417 if (bus->wqueue_size > 0)
3420 r = bus_kernel_try_close(bus);
3428 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3429 assert_return(bus, -EINVAL);
3430 assert_return(description, -EINVAL);
3431 assert_return(bus->description, -ENXIO);
3432 assert_return(!bus_pid_changed(bus), -ECHILD);
3434 *description = bus->description;
3438 int bus_get_root_path(sd_bus *bus) {
3441 if (bus->cgroup_root)
3444 r = cg_get_root_path(&bus->cgroup_root);
3446 bus->cgroup_root = strdup("/");
3447 if (!bus->cgroup_root)
3456 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3459 assert_return(bus, -EINVAL);
3460 assert_return(scope, -EINVAL);
3461 assert_return(!bus_pid_changed(bus), -ECHILD);
3463 if (bus->is_kernel) {
3464 _cleanup_free_ char *n = NULL;
3467 r = bus_kernel_get_bus_name(bus, &n);
3471 if (streq(n, "0-system")) {
3476 dash = strchr(n, '-');
3477 if (streq_ptr(dash, "-user")) {
3488 if (bus->is_system) {
3496 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3498 assert_return(bus, -EINVAL);
3499 assert_return(address, -EINVAL);
3500 assert_return(!bus_pid_changed(bus), -ECHILD);
3503 *address = bus->address;
3510 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3511 assert_return(bus, -EINVAL);
3512 assert_return(mask, -EINVAL);
3513 assert_return(!bus_pid_changed(bus), -ECHILD);
3515 *mask = bus->creds_mask;
3519 int sd_bus_is_bus_client(sd_bus *bus) {
3520 assert_return(bus, -EINVAL);
3521 assert_return(!bus_pid_changed(bus), -ECHILD);
3523 return bus->bus_client;
3526 int sd_bus_is_server(sd_bus *bus) {
3527 assert_return(bus, -EINVAL);
3528 assert_return(!bus_pid_changed(bus), -ECHILD);
3530 return bus->is_server;
3533 int sd_bus_is_anonymous(sd_bus *bus) {
3534 assert_return(bus, -EINVAL);
3535 assert_return(!bus_pid_changed(bus), -ECHILD);
3537 return bus->anonymous_auth;
3540 int sd_bus_is_trusted(sd_bus *bus) {
3541 assert_return(bus, -EINVAL);
3542 assert_return(!bus_pid_changed(bus), -ECHILD);
3544 return bus->trusted;
3547 int sd_bus_is_monitor(sd_bus *bus) {
3548 assert_return(bus, -EINVAL);
3549 assert_return(!bus_pid_changed(bus), -ECHILD);
3551 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);