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 *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
375 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
378 r = sd_bus_message_get_errno(reply);
382 r = sd_bus_message_read(reply, "s", &s);
386 if (!service_name_is_valid(s) || s[0] != ':')
389 bus->unique_name = strdup(s);
390 if (!bus->unique_name)
393 if (bus->state == BUS_HELLO)
394 bus->state = BUS_RUNNING;
399 static int bus_send_hello(sd_bus *bus) {
400 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
405 if (!bus->bus_client || bus->is_kernel)
408 r = sd_bus_message_new_method_call(
411 "org.freedesktop.DBus",
412 "/org/freedesktop/DBus",
413 "org.freedesktop.DBus",
418 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
421 int bus_start_running(sd_bus *bus) {
424 if (bus->bus_client && !bus->is_kernel) {
425 bus->state = BUS_HELLO;
429 bus->state = BUS_RUNNING;
433 static int parse_address_key(const char **p, const char *key, char **value) {
434 size_t l, n = 0, allocated = 0;
444 if (strncmp(*p, key, l) != 0)
457 while (*a != ';' && *a != ',' && *a != 0) {
475 c = (char) ((x << 4) | y);
482 if (!GREEDY_REALLOC(r, allocated, n + 2))
506 static void skip_address_key(const char **p) {
510 *p += strcspn(*p, ",");
516 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
517 _cleanup_free_ char *path = NULL, *abstract = NULL;
526 while (**p != 0 && **p != ';') {
527 r = parse_address_key(p, "guid", guid);
533 r = parse_address_key(p, "path", &path);
539 r = parse_address_key(p, "abstract", &abstract);
548 if (!path && !abstract)
551 if (path && abstract)
556 if (l > sizeof(b->sockaddr.un.sun_path))
559 b->sockaddr.un.sun_family = AF_UNIX;
560 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
561 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
562 } else if (abstract) {
563 l = strlen(abstract);
564 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
567 b->sockaddr.un.sun_family = AF_UNIX;
568 b->sockaddr.un.sun_path[0] = 0;
569 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
570 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
576 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
577 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
579 struct addrinfo *result, hints = {
580 .ai_socktype = SOCK_STREAM,
581 .ai_flags = AI_ADDRCONFIG,
589 while (**p != 0 && **p != ';') {
590 r = parse_address_key(p, "guid", guid);
596 r = parse_address_key(p, "host", &host);
602 r = parse_address_key(p, "port", &port);
608 r = parse_address_key(p, "family", &family);
621 if (streq(family, "ipv4"))
622 hints.ai_family = AF_INET;
623 else if (streq(family, "ipv6"))
624 hints.ai_family = AF_INET6;
629 r = getaddrinfo(host, port, &hints, &result);
633 return -EADDRNOTAVAIL;
635 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
636 b->sockaddr_size = result->ai_addrlen;
638 freeaddrinfo(result);
643 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
645 unsigned n_argv = 0, j;
647 size_t allocated = 0;
655 while (**p != 0 && **p != ';') {
656 r = parse_address_key(p, "guid", guid);
662 r = parse_address_key(p, "path", &path);
668 if (startswith(*p, "argv")) {
672 ul = strtoul(*p + 4, (char**) p, 10);
673 if (errno > 0 || **p != '=' || ul > 256) {
681 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
689 r = parse_address_key(p, NULL, argv + ul);
704 /* Make sure there are no holes in the array, with the
705 * exception of argv[0] */
706 for (j = 1; j < n_argv; j++)
712 if (argv && argv[0] == NULL) {
713 argv[0] = strdup(path);
725 for (j = 0; j < n_argv; j++)
733 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
734 _cleanup_free_ char *path = NULL;
742 while (**p != 0 && **p != ';') {
743 r = parse_address_key(p, "guid", guid);
749 r = parse_address_key(p, "path", &path);
768 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
769 _cleanup_free_ char *machine = NULL, *pid = NULL;
777 while (**p != 0 && **p != ';') {
778 r = parse_address_key(p, "guid", guid);
784 r = parse_address_key(p, "machine", &machine);
790 r = parse_address_key(p, "pid", &pid);
799 if (!machine == !pid)
803 if (!machine_name_is_valid(machine))
807 b->machine = machine;
815 r = parse_pid(pid, &b->nspid);
821 b->sockaddr.un.sun_family = AF_UNIX;
822 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
823 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
828 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
829 _cleanup_free_ char *machine = NULL, *pid = NULL;
837 while (**p != 0 && **p != ';') {
838 r = parse_address_key(p, "guid", guid);
844 r = parse_address_key(p, "machine", &machine);
850 r = parse_address_key(p, "pid", &pid);
859 if (!machine == !pid)
863 if (!machine_name_is_valid(machine))
867 b->machine = machine;
875 r = parse_pid(pid, &b->nspid);
882 b->kernel = strdup("/sys/fs/kdbus/0-system/bus");
889 static void bus_reset_parsed_address(sd_bus *b) {
893 b->sockaddr_size = 0;
894 strv_free(b->exec_argv);
898 b->server_id = SD_ID128_NULL;
906 static int bus_parse_next_address(sd_bus *b) {
907 _cleanup_free_ char *guid = NULL;
915 if (b->address[b->address_index] == 0)
918 bus_reset_parsed_address(b);
920 a = b->address + b->address_index;
929 if (startswith(a, "unix:")) {
932 r = parse_unix_address(b, &a, &guid);
937 } else if (startswith(a, "tcp:")) {
940 r = parse_tcp_address(b, &a, &guid);
946 } else if (startswith(a, "unixexec:")) {
949 r = parse_exec_address(b, &a, &guid);
955 } else if (startswith(a, "kernel:")) {
958 r = parse_kernel_address(b, &a, &guid);
963 } else if (startswith(a, "x-machine-unix:")) {
966 r = parse_container_unix_address(b, &a, &guid);
971 } else if (startswith(a, "x-machine-kernel:")) {
974 r = parse_container_kernel_address(b, &a, &guid);
987 r = sd_id128_from_string(guid, &b->server_id);
992 b->address_index = a - b->address;
996 static int bus_start_address(sd_bus *b) {
1002 bool skipped = false;
1007 r = bus_socket_exec(b);
1008 else if ((b->nspid > 0 || b->machine) && b->kernel)
1009 r = bus_container_connect_kernel(b);
1010 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1011 r = bus_container_connect_socket(b);
1013 r = bus_kernel_connect(b);
1014 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1015 r = bus_socket_connect(b);
1021 r = attach_io_events(b);
1026 b->last_connect_error = -r;
1029 r = bus_parse_next_address(b);
1033 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1037 int bus_next_address(sd_bus *b) {
1040 bus_reset_parsed_address(b);
1041 return bus_start_address(b);
1044 static int bus_start_fd(sd_bus *b) {
1049 assert(b->input_fd >= 0);
1050 assert(b->output_fd >= 0);
1052 r = fd_nonblock(b->input_fd, true);
1056 r = fd_cloexec(b->input_fd, true);
1060 if (b->input_fd != b->output_fd) {
1061 r = fd_nonblock(b->output_fd, true);
1065 r = fd_cloexec(b->output_fd, true);
1070 if (fstat(b->input_fd, &st) < 0)
1073 if (S_ISCHR(b->input_fd))
1074 return bus_kernel_take_fd(b);
1076 return bus_socket_take_fd(b);
1079 _public_ int sd_bus_start(sd_bus *bus) {
1082 assert_return(bus, -EINVAL);
1083 assert_return(bus->state == BUS_UNSET, -EPERM);
1084 assert_return(!bus_pid_changed(bus), -ECHILD);
1086 bus->state = BUS_OPENING;
1088 if (bus->is_server && bus->bus_client)
1091 if (bus->input_fd >= 0)
1092 r = bus_start_fd(bus);
1093 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1094 r = bus_start_address(bus);
1103 return bus_send_hello(bus);
1106 _public_ int sd_bus_open(sd_bus **ret) {
1111 assert_return(ret, -EINVAL);
1113 /* Let's connect to the starter bus if it is set, and
1114 * otherwise to the bus that is appropropriate for the scope
1115 * we are running in */
1117 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1119 if (streq(e, "system"))
1120 return sd_bus_open_system(ret);
1121 else if (STR_IN_SET(e, "session", "user"))
1122 return sd_bus_open_user(ret);
1125 e = secure_getenv("DBUS_STARTER_ADDRESS");
1127 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1128 return sd_bus_open_user(ret);
1130 return sd_bus_open_system(ret);
1137 r = sd_bus_set_address(b, e);
1141 b->bus_client = true;
1143 /* We don't know whether the bus is trusted or not, so better
1144 * be safe, and authenticate everything */
1146 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1147 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1149 r = sd_bus_start(b);
1161 int bus_set_address_system(sd_bus *b) {
1165 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1167 return sd_bus_set_address(b, e);
1169 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1172 _public_ int sd_bus_open_system(sd_bus **ret) {
1176 assert_return(ret, -EINVAL);
1182 r = bus_set_address_system(b);
1186 b->bus_client = true;
1187 b->is_system = true;
1189 /* Let's do per-method access control on the system bus. We
1190 * need the caller's UID and capability set for that. */
1192 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1193 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1195 r = sd_bus_start(b);
1207 int bus_set_address_user(sd_bus *b) {
1212 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1214 return sd_bus_set_address(b, e);
1216 e = secure_getenv("XDG_RUNTIME_DIR");
1218 _cleanup_free_ char *ee = NULL;
1220 ee = bus_address_escape(e);
1225 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1227 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1231 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1233 return -ECONNREFUSED;
1243 _public_ int sd_bus_open_user(sd_bus **ret) {
1247 assert_return(ret, -EINVAL);
1253 r = bus_set_address_user(b);
1257 b->bus_client = true;
1260 /* We don't do any per-method access control on the user
1264 r = sd_bus_start(b);
1276 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1277 _cleanup_free_ char *e = NULL;
1278 char *m = NULL, *c = NULL;
1283 /* Let's see if we shall enter some container */
1284 m = strchr(host, ':');
1288 /* Let's make sure this is not a port of some kind,
1289 * and is a valid machine name. */
1290 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1293 /* Cut out the host part */
1294 t = strndupa(host, m - host - 1);
1295 e = bus_address_escape(t);
1299 c = strjoina(",argv4=--machine=", m);
1304 e = bus_address_escape(host);
1309 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1316 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1320 assert_return(host, -EINVAL);
1321 assert_return(ret, -EINVAL);
1323 r = sd_bus_new(&bus);
1327 r = bus_set_address_system_remote(bus, host);
1331 bus->bus_client = true;
1332 bus->trusted = false;
1333 bus->is_system = true;
1335 r = sd_bus_start(bus);
1347 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1348 _cleanup_free_ char *e = NULL;
1353 e = bus_address_escape(machine);
1358 b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1360 b->address = strjoin("x-machine-unix:machine=", e, NULL);
1368 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1372 assert_return(machine, -EINVAL);
1373 assert_return(ret, -EINVAL);
1374 assert_return(machine_name_is_valid(machine), -EINVAL);
1376 r = sd_bus_new(&bus);
1380 r = bus_set_address_system_machine(bus, machine);
1384 bus->bus_client = true;
1385 bus->trusted = false;
1386 bus->is_system = true;
1388 r = sd_bus_start(bus);
1400 _public_ void sd_bus_close(sd_bus *bus) {
1404 if (bus->state == BUS_CLOSED)
1406 if (bus_pid_changed(bus))
1409 bus->state = BUS_CLOSED;
1411 sd_bus_detach_event(bus);
1413 /* Drop all queued messages so that they drop references to
1414 * the bus object and the bus may be freed */
1415 bus_reset_queues(bus);
1417 if (!bus->is_kernel)
1420 /* We'll leave the fd open in case this is a kernel bus, since
1421 * there might still be memblocks around that reference this
1422 * bus, and they might need to invoke the KDBUS_CMD_FREE
1423 * ioctl on the fd when they are freed. */
1426 static void bus_enter_closing(sd_bus *bus) {
1429 if (bus->state != BUS_OPENING &&
1430 bus->state != BUS_AUTHENTICATING &&
1431 bus->state != BUS_HELLO &&
1432 bus->state != BUS_RUNNING)
1435 bus->state = BUS_CLOSING;
1438 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1439 assert_return(bus, NULL);
1441 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1446 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1452 i = REFCNT_DEC(bus->n_ref);
1460 _public_ int sd_bus_is_open(sd_bus *bus) {
1462 assert_return(bus, -EINVAL);
1463 assert_return(!bus_pid_changed(bus), -ECHILD);
1465 return BUS_IS_OPEN(bus->state);
1468 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1471 assert_return(bus, -EINVAL);
1472 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1473 assert_return(!bus_pid_changed(bus), -ECHILD);
1475 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1478 if (type == SD_BUS_TYPE_UNIX_FD) {
1479 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1482 r = bus_ensure_running(bus);
1486 return bus->can_fds;
1489 return bus_type_is_valid(type);
1492 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1495 assert_return(bus, -EINVAL);
1496 assert_return(id, -EINVAL);
1497 assert_return(!bus_pid_changed(bus), -ECHILD);
1499 r = bus_ensure_running(bus);
1503 *id = bus->server_id;
1507 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1512 /* If we copy the same message to multiple
1513 * destinations, avoid using the same cookie
1515 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1520 timeout = BUS_DEFAULT_TIMEOUT;
1522 return bus_message_seal(m, ++b->cookie, timeout);
1525 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1528 /* Do packet version and endianness already match? */
1529 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1530 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1533 /* No? Then remarshal! */
1534 return bus_message_remarshal(b, m);
1537 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1541 /* Fake some timestamps, if they were requested, and not
1542 * already initialized */
1543 if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1544 if (m->realtime <= 0)
1545 m->realtime = now(CLOCK_REALTIME);
1547 if (m->monotonic <= 0)
1548 m->monotonic = now(CLOCK_MONOTONIC);
1551 /* The bus specification says the serial number cannot be 0,
1552 * hence let's fill something in for synthetic messages. Since
1553 * synthetic messages might have a fake sender and we don't
1554 * want to interfere with the real sender's serial numbers we
1555 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1556 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1557 * even though kdbus can do 64bit. */
1558 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1561 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1568 r = bus_kernel_write_message(bus, m, hint_sync_call);
1570 r = bus_socket_write_message(bus, m, idx);
1575 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1576 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1577 bus_message_type_to_string(m->header->type),
1578 strna(sd_bus_message_get_sender(m)),
1579 strna(sd_bus_message_get_destination(m)),
1580 strna(sd_bus_message_get_path(m)),
1581 strna(sd_bus_message_get_interface(m)),
1582 strna(sd_bus_message_get_member(m)),
1583 BUS_MESSAGE_COOKIE(m),
1585 strna(m->error.message));
1590 static int dispatch_wqueue(sd_bus *bus) {
1594 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1596 while (bus->wqueue_size > 0) {
1598 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1602 /* Didn't do anything this time */
1604 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1605 /* Fully written. Let's drop the entry from
1608 * This isn't particularly optimized, but
1609 * well, this is supposed to be our worst-case
1610 * buffer only, and the socket buffer is
1611 * supposed to be our primary buffer, and if
1612 * it got full, then all bets are off
1615 bus->wqueue_size --;
1616 sd_bus_message_unref(bus->wqueue[0]);
1617 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1627 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1631 return bus_kernel_read_message(bus, hint_priority, priority);
1633 return bus_socket_read_message(bus);
1636 int bus_rqueue_make_room(sd_bus *bus) {
1639 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1642 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1648 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1653 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1655 /* Note that the priority logic is only available on kdbus,
1656 * where the rqueue is unused. We check the rqueue here
1657 * anyway, because it's simple... */
1660 if (bus->rqueue_size > 0) {
1661 /* Dispatch a queued message */
1663 *m = bus->rqueue[0];
1664 bus->rqueue_size --;
1665 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1669 /* Try to read a new message */
1670 r = bus_read_message(bus, hint_priority, priority);
1680 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1681 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1684 assert_return(bus, -EINVAL);
1685 assert_return(m, -EINVAL);
1686 assert_return(!bus_pid_changed(bus), -ECHILD);
1687 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1689 if (!BUS_IS_OPEN(bus->state))
1693 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1700 /* If the cookie number isn't kept, then we know that no reply
1702 if (!cookie && !m->sealed)
1703 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1705 r = bus_seal_message(bus, m, 0);
1709 /* Remarshall if we have to. This will possibly unref the
1710 * message and place a replacement in m */
1711 r = bus_remarshal_message(bus, &m);
1715 /* If this is a reply and no reply was requested, then let's
1716 * suppress this, if we can */
1720 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1723 r = bus_write_message(bus, m, hint_sync_call, &idx);
1725 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1726 bus_enter_closing(bus);
1733 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1734 /* Wasn't fully written. So let's remember how
1735 * much was written. Note that the first entry
1736 * of the wqueue array is always allocated so
1737 * that we always can remember how much was
1739 bus->wqueue[0] = sd_bus_message_ref(m);
1740 bus->wqueue_size = 1;
1745 /* Just append it to the queue. */
1747 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1750 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1753 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1758 *cookie = BUS_MESSAGE_COOKIE(m);
1763 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1764 return bus_send_internal(bus, m, cookie, false);
1767 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1770 assert_return(bus, -EINVAL);
1771 assert_return(m, -EINVAL);
1772 assert_return(!bus_pid_changed(bus), -ECHILD);
1774 if (!BUS_IS_OPEN(bus->state))
1777 if (!streq_ptr(m->destination, destination)) {
1782 r = sd_bus_message_set_destination(m, destination);
1787 return sd_bus_send(bus, m, cookie);
1790 static usec_t calc_elapse(uint64_t usec) {
1791 if (usec == (uint64_t) -1)
1794 return now(CLOCK_MONOTONIC) + usec;
1797 static int timeout_compare(const void *a, const void *b) {
1798 const struct reply_callback *x = a, *y = b;
1800 if (x->timeout != 0 && y->timeout == 0)
1803 if (x->timeout == 0 && y->timeout != 0)
1806 if (x->timeout < y->timeout)
1809 if (x->timeout > y->timeout)
1815 _public_ int sd_bus_call_async(
1819 sd_bus_message_handler_t callback,
1823 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1824 _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1827 assert_return(bus, -EINVAL);
1828 assert_return(m, -EINVAL);
1829 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1830 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1831 assert_return(callback, -EINVAL);
1832 assert_return(!bus_pid_changed(bus), -ECHILD);
1833 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1835 if (!BUS_IS_OPEN(bus->state))
1838 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1842 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1846 r = bus_seal_message(bus, m, usec);
1850 r = bus_remarshal_message(bus, &m);
1854 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1858 s->reply_callback.callback = callback;
1860 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1861 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1863 s->reply_callback.cookie = 0;
1867 s->reply_callback.timeout = calc_elapse(m->timeout);
1868 if (s->reply_callback.timeout != 0) {
1869 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1871 s->reply_callback.timeout = 0;
1876 r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1887 int bus_ensure_running(sd_bus *bus) {
1892 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1894 if (bus->state == BUS_RUNNING)
1898 r = sd_bus_process(bus, NULL);
1901 if (bus->state == BUS_RUNNING)
1906 r = sd_bus_wait(bus, (uint64_t) -1);
1912 _public_ int sd_bus_call(
1916 sd_bus_error *error,
1917 sd_bus_message **reply) {
1919 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1925 assert_return(bus, -EINVAL);
1926 assert_return(m, -EINVAL);
1927 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1928 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1929 assert_return(!bus_error_is_dirty(error), -EINVAL);
1930 assert_return(!bus_pid_changed(bus), -ECHILD);
1931 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1933 if (!BUS_IS_OPEN(bus->state))
1936 r = bus_ensure_running(bus);
1940 i = bus->rqueue_size;
1942 r = bus_seal_message(bus, m, usec);
1946 r = bus_remarshal_message(bus, &m);
1950 r = bus_send_internal(bus, m, &cookie, true);
1954 timeout = calc_elapse(m->timeout);
1959 while (i < bus->rqueue_size) {
1960 sd_bus_message *incoming = NULL;
1962 incoming = bus->rqueue[i];
1964 if (incoming->reply_cookie == cookie) {
1965 /* Found a match! */
1967 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1970 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1972 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1976 sd_bus_message_unref(incoming);
1981 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1983 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1984 r = sd_bus_error_copy(error, &incoming->error);
1988 sd_bus_message_unref(incoming);
1991 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1994 streq(bus->unique_name, incoming->sender)) {
1996 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1999 /* Our own message? Somebody is trying
2000 * to send its own client a message,
2001 * let's not dead-lock, let's fail
2004 sd_bus_message_unref(incoming);
2008 /* Try to read more, right-away */
2012 r = bus_read_message(bus, false, 0);
2014 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2015 bus_enter_closing(bus);
2027 n = now(CLOCK_MONOTONIC);
2033 left = (uint64_t) -1;
2035 r = bus_poll(bus, true, left);
2041 r = dispatch_wqueue(bus);
2043 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2044 bus_enter_closing(bus);
2053 _public_ int sd_bus_get_fd(sd_bus *bus) {
2055 assert_return(bus, -EINVAL);
2056 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2057 assert_return(!bus_pid_changed(bus), -ECHILD);
2059 return bus->input_fd;
2062 _public_ int sd_bus_get_events(sd_bus *bus) {
2065 assert_return(bus, -EINVAL);
2066 assert_return(!bus_pid_changed(bus), -ECHILD);
2068 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2071 if (bus->state == BUS_OPENING)
2073 else if (bus->state == BUS_AUTHENTICATING) {
2075 if (bus_socket_auth_needs_write(bus))
2080 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2081 if (bus->rqueue_size <= 0)
2083 if (bus->wqueue_size > 0)
2090 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2091 struct reply_callback *c;
2093 assert_return(bus, -EINVAL);
2094 assert_return(timeout_usec, -EINVAL);
2095 assert_return(!bus_pid_changed(bus), -ECHILD);
2097 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2100 if (bus->track_queue) {
2105 if (bus->state == BUS_CLOSING) {
2110 if (bus->state == BUS_AUTHENTICATING) {
2111 *timeout_usec = bus->auth_timeout;
2115 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2116 *timeout_usec = (uint64_t) -1;
2120 if (bus->rqueue_size > 0) {
2125 c = prioq_peek(bus->reply_callbacks_prioq);
2127 *timeout_usec = (uint64_t) -1;
2131 if (c->timeout == 0) {
2132 *timeout_usec = (uint64_t) -1;
2136 *timeout_usec = c->timeout;
2140 static int process_timeout(sd_bus *bus) {
2141 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2142 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2143 struct reply_callback *c;
2150 c = prioq_peek(bus->reply_callbacks_prioq);
2154 n = now(CLOCK_MONOTONIC);
2158 r = bus_message_new_synthetic_error(
2161 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2166 r = bus_seal_synthetic_message(bus, m);
2170 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2173 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2176 slot = container_of(c, sd_bus_slot, reply_callback);
2178 bus->iteration_counter ++;
2180 bus->current_message = m;
2181 bus->current_slot = sd_bus_slot_ref(slot);
2182 bus->current_handler = c->callback;
2183 bus->current_userdata = slot->userdata;
2184 r = c->callback(bus, m, slot->userdata, &error_buffer);
2185 bus->current_userdata = NULL;
2186 bus->current_handler = NULL;
2187 bus->current_slot = NULL;
2188 bus->current_message = NULL;
2190 if (slot->floating) {
2191 bus_slot_disconnect(slot);
2192 sd_bus_slot_unref(slot);
2195 sd_bus_slot_unref(slot);
2197 return bus_maybe_reply_error(m, r, &error_buffer);
2200 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2204 if (bus->state != BUS_HELLO)
2207 /* Let's make sure the first message on the bus is the HELLO
2208 * reply. But note that we don't actually parse the message
2209 * here (we leave that to the usual handling), we just verify
2210 * we don't let any earlier msg through. */
2212 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2213 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2216 if (m->reply_cookie != 1)
2222 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2223 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2224 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2225 struct reply_callback *c;
2232 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2233 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2236 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2239 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2242 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2248 slot = container_of(c, sd_bus_slot, reply_callback);
2250 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2252 /* If the reply contained a file descriptor which we
2253 * didn't want we pass an error instead. */
2255 r = bus_message_new_synthetic_error(
2258 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2263 /* Copy over original timestamp */
2264 synthetic_reply->realtime = m->realtime;
2265 synthetic_reply->monotonic = m->monotonic;
2266 synthetic_reply->seqnum = m->seqnum;
2268 r = bus_seal_synthetic_message(bus, synthetic_reply);
2272 m = synthetic_reply;
2274 r = sd_bus_message_rewind(m, true);
2279 if (c->timeout != 0) {
2280 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2284 bus->current_slot = sd_bus_slot_ref(slot);
2285 bus->current_handler = c->callback;
2286 bus->current_userdata = slot->userdata;
2287 r = c->callback(bus, m, slot->userdata, &error_buffer);
2288 bus->current_userdata = NULL;
2289 bus->current_handler = NULL;
2290 bus->current_slot = NULL;
2292 if (slot->floating) {
2293 bus_slot_disconnect(slot);
2294 sd_bus_slot_unref(slot);
2297 sd_bus_slot_unref(slot);
2299 return bus_maybe_reply_error(m, r, &error_buffer);
2302 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2303 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2304 struct filter_callback *l;
2311 bus->filter_callbacks_modified = false;
2313 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2316 if (bus->filter_callbacks_modified)
2319 /* Don't run this more than once per iteration */
2320 if (l->last_iteration == bus->iteration_counter)
2323 l->last_iteration = bus->iteration_counter;
2325 r = sd_bus_message_rewind(m, true);
2329 slot = container_of(l, sd_bus_slot, filter_callback);
2331 bus->current_slot = sd_bus_slot_ref(slot);
2332 bus->current_handler = l->callback;
2333 bus->current_userdata = slot->userdata;
2334 r = l->callback(bus, m, slot->userdata, &error_buffer);
2335 bus->current_userdata = NULL;
2336 bus->current_handler = NULL;
2337 bus->current_slot = sd_bus_slot_unref(slot);
2339 r = bus_maybe_reply_error(m, r, &error_buffer);
2345 } while (bus->filter_callbacks_modified);
2350 static int process_match(sd_bus *bus, sd_bus_message *m) {
2357 bus->match_callbacks_modified = false;
2359 r = bus_match_run(bus, &bus->match_callbacks, m);
2363 } while (bus->match_callbacks_modified);
2368 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2369 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2375 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2378 if (bus->manual_peer_interface)
2381 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2384 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2387 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2390 if (streq_ptr(m->member, "Ping"))
2391 r = sd_bus_message_new_method_return(m, &reply);
2392 else if (streq_ptr(m->member, "GetMachineId")) {
2396 r = sd_id128_get_machine(&id);
2400 r = sd_bus_message_new_method_return(m, &reply);
2404 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2406 r = sd_bus_message_new_method_errorf(
2408 SD_BUS_ERROR_UNKNOWN_METHOD,
2409 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2415 r = sd_bus_send(bus, reply, NULL);
2422 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2426 /* If we got a message with a file descriptor which we didn't
2427 * want to accept, then let's drop it. How can this even
2428 * happen? For example, when the kernel queues a message into
2429 * an activatable names's queue which allows fds, and then is
2430 * delivered to us later even though we ourselves did not
2433 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2439 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2442 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2443 return 1; /* just eat it up */
2445 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2448 static int process_message(sd_bus *bus, sd_bus_message *m) {
2454 bus->current_message = m;
2455 bus->iteration_counter++;
2457 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2458 bus_message_type_to_string(m->header->type),
2459 strna(sd_bus_message_get_sender(m)),
2460 strna(sd_bus_message_get_destination(m)),
2461 strna(sd_bus_message_get_path(m)),
2462 strna(sd_bus_message_get_interface(m)),
2463 strna(sd_bus_message_get_member(m)),
2464 BUS_MESSAGE_COOKIE(m),
2466 strna(m->error.message));
2468 r = process_hello(bus, m);
2472 r = process_reply(bus, m);
2476 r = process_fd_check(bus, m);
2480 r = process_filter(bus, m);
2484 r = process_match(bus, m);
2488 r = process_builtin(bus, m);
2492 r = bus_process_object(bus, m);
2495 bus->current_message = NULL;
2499 static int dispatch_track(sd_bus *bus) {
2502 if (!bus->track_queue)
2505 bus_track_dispatch(bus->track_queue);
2509 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2510 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2514 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2516 r = process_timeout(bus);
2520 r = dispatch_wqueue(bus);
2524 r = dispatch_track(bus);
2528 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2534 r = process_message(bus, m);
2539 r = sd_bus_message_rewind(m, true);
2548 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2550 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2551 strna(sd_bus_message_get_sender(m)),
2552 strna(sd_bus_message_get_path(m)),
2553 strna(sd_bus_message_get_interface(m)),
2554 strna(sd_bus_message_get_member(m)));
2556 r = sd_bus_reply_method_errorf(
2558 SD_BUS_ERROR_UNKNOWN_OBJECT,
2559 "Unknown object '%s'.", m->path);
2573 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2574 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2575 struct reply_callback *c;
2579 assert(bus->state == BUS_CLOSING);
2581 c = ordered_hashmap_first(bus->reply_callbacks);
2583 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2586 /* First, fail all outstanding method calls */
2587 r = bus_message_new_synthetic_error(
2590 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2595 r = bus_seal_synthetic_message(bus, m);
2599 if (c->timeout != 0) {
2600 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2604 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2607 slot = container_of(c, sd_bus_slot, reply_callback);
2609 bus->iteration_counter++;
2611 bus->current_message = m;
2612 bus->current_slot = sd_bus_slot_ref(slot);
2613 bus->current_handler = c->callback;
2614 bus->current_userdata = slot->userdata;
2615 r = c->callback(bus, m, slot->userdata, &error_buffer);
2616 bus->current_userdata = NULL;
2617 bus->current_handler = NULL;
2618 bus->current_slot = NULL;
2619 bus->current_message = NULL;
2621 if (slot->floating) {
2622 bus_slot_disconnect(slot);
2623 sd_bus_slot_unref(slot);
2626 sd_bus_slot_unref(slot);
2628 return bus_maybe_reply_error(m, r, &error_buffer);
2631 /* Then, synthesize a Disconnected message */
2632 r = sd_bus_message_new_signal(
2635 "/org/freedesktop/DBus/Local",
2636 "org.freedesktop.DBus.Local",
2641 bus_message_set_sender_local(bus, m);
2643 r = bus_seal_synthetic_message(bus, m);
2649 bus->current_message = m;
2650 bus->iteration_counter++;
2652 r = process_filter(bus, m);
2656 r = process_match(bus, m);
2668 bus->current_message = NULL;
2673 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2674 BUS_DONT_DESTROY(bus);
2677 /* Returns 0 when we didn't do anything. This should cause the
2678 * caller to invoke sd_bus_wait() before returning the next
2679 * time. Returns > 0 when we did something, which possibly
2680 * means *ret is filled in with an unprocessed message. */
2682 assert_return(bus, -EINVAL);
2683 assert_return(!bus_pid_changed(bus), -ECHILD);
2685 /* We don't allow recursively invoking sd_bus_process(). */
2686 assert_return(!bus->current_message, -EBUSY);
2687 assert(!bus->current_slot);
2689 switch (bus->state) {
2698 r = bus_socket_process_opening(bus);
2699 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2700 bus_enter_closing(bus);
2708 case BUS_AUTHENTICATING:
2709 r = bus_socket_process_authenticating(bus);
2710 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2711 bus_enter_closing(bus);
2723 r = process_running(bus, hint_priority, priority, ret);
2724 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2725 bus_enter_closing(bus);
2735 return process_closing(bus, ret);
2738 assert_not_reached("Unknown state");
2741 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2742 return bus_process_internal(bus, false, 0, ret);
2745 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2746 return bus_process_internal(bus, true, priority, ret);
2749 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2750 struct pollfd p[2] = {};
2753 usec_t m = USEC_INFINITY;
2757 if (bus->state == BUS_CLOSING)
2760 if (!BUS_IS_OPEN(bus->state))
2763 e = sd_bus_get_events(bus);
2768 /* The caller really needs some more data, he doesn't
2769 * care about what's already read, or any timeouts
2770 * except its own. */
2774 /* The caller wants to process if there's something to
2775 * process, but doesn't care otherwise */
2777 r = sd_bus_get_timeout(bus, &until);
2782 nw = now(CLOCK_MONOTONIC);
2783 m = until > nw ? until - nw : 0;
2787 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2790 p[0].fd = bus->input_fd;
2791 if (bus->output_fd == bus->input_fd) {
2795 p[0].events = e & POLLIN;
2796 p[1].fd = bus->output_fd;
2797 p[1].events = e & POLLOUT;
2801 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2805 return r > 0 ? 1 : 0;
2808 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2810 assert_return(bus, -EINVAL);
2811 assert_return(!bus_pid_changed(bus), -ECHILD);
2813 if (bus->state == BUS_CLOSING)
2816 if (!BUS_IS_OPEN(bus->state))
2819 if (bus->rqueue_size > 0)
2822 return bus_poll(bus, false, timeout_usec);
2825 _public_ int sd_bus_flush(sd_bus *bus) {
2828 assert_return(bus, -EINVAL);
2829 assert_return(!bus_pid_changed(bus), -ECHILD);
2831 if (bus->state == BUS_CLOSING)
2834 if (!BUS_IS_OPEN(bus->state))
2837 r = bus_ensure_running(bus);
2841 if (bus->wqueue_size <= 0)
2845 r = dispatch_wqueue(bus);
2847 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2848 bus_enter_closing(bus);
2855 if (bus->wqueue_size <= 0)
2858 r = bus_poll(bus, false, (uint64_t) -1);
2864 _public_ int sd_bus_add_filter(
2867 sd_bus_message_handler_t callback,
2872 assert_return(bus, -EINVAL);
2873 assert_return(callback, -EINVAL);
2874 assert_return(!bus_pid_changed(bus), -ECHILD);
2876 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2880 s->filter_callback.callback = callback;
2882 bus->filter_callbacks_modified = true;
2883 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2891 _public_ int sd_bus_add_match(
2895 sd_bus_message_handler_t callback,
2898 struct bus_match_component *components = NULL;
2899 unsigned n_components = 0;
2900 sd_bus_slot *s = NULL;
2903 assert_return(bus, -EINVAL);
2904 assert_return(match, -EINVAL);
2905 assert_return(!bus_pid_changed(bus), -ECHILD);
2907 r = bus_match_parse(match, &components, &n_components);
2911 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2917 s->match_callback.callback = callback;
2918 s->match_callback.cookie = ++bus->match_cookie;
2920 if (bus->bus_client) {
2922 if (!bus->is_kernel) {
2923 /* When this is not a kernel transport, we
2924 * store the original match string, so that we
2925 * can use it to remove the match again */
2927 s->match_callback.match_string = strdup(match);
2928 if (!s->match_callback.match_string) {
2934 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2939 bus->match_callbacks_modified = true;
2940 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2949 bus_match_parse_free(components, n_components);
2950 sd_bus_slot_unref(s);
2955 int bus_remove_match_by_string(
2958 sd_bus_message_handler_t callback,
2961 struct bus_match_component *components = NULL;
2962 unsigned n_components = 0;
2963 struct match_callback *c;
2966 assert_return(bus, -EINVAL);
2967 assert_return(match, -EINVAL);
2968 assert_return(!bus_pid_changed(bus), -ECHILD);
2970 r = bus_match_parse(match, &components, &n_components);
2974 r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2978 sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2981 bus_match_parse_free(components, n_components);
2986 bool bus_pid_changed(sd_bus *bus) {
2989 /* We don't support people creating a bus connection and
2990 * keeping it around over a fork(). Let's complain. */
2992 return bus->original_pid != getpid();
2995 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2996 sd_bus *bus = userdata;
3001 r = sd_bus_process(bus, NULL);
3008 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3009 sd_bus *bus = userdata;
3014 r = sd_bus_process(bus, NULL);
3021 static int prepare_callback(sd_event_source *s, void *userdata) {
3022 sd_bus *bus = userdata;
3029 e = sd_bus_get_events(bus);
3033 if (bus->output_fd != bus->input_fd) {
3035 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3039 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3043 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3048 r = sd_bus_get_timeout(bus, &until);
3054 j = sd_event_source_set_time(bus->time_event_source, until);
3059 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3066 static int quit_callback(sd_event_source *event, void *userdata) {
3067 sd_bus *bus = userdata;
3077 static int attach_io_events(sd_bus *bus) {
3082 if (bus->input_fd < 0)
3088 if (!bus->input_io_event_source) {
3089 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3093 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3097 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3101 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3103 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3108 if (bus->output_fd != bus->input_fd) {
3109 assert(bus->output_fd >= 0);
3111 if (!bus->output_io_event_source) {
3112 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3116 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3120 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3122 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3131 static void detach_io_events(sd_bus *bus) {
3134 if (bus->input_io_event_source) {
3135 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3136 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3139 if (bus->output_io_event_source) {
3140 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3141 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3145 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3148 assert_return(bus, -EINVAL);
3149 assert_return(!bus->event, -EBUSY);
3151 assert(!bus->input_io_event_source);
3152 assert(!bus->output_io_event_source);
3153 assert(!bus->time_event_source);
3156 bus->event = sd_event_ref(event);
3158 r = sd_event_default(&bus->event);
3163 bus->event_priority = priority;
3165 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3169 r = sd_event_source_set_priority(bus->time_event_source, priority);
3173 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3177 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3181 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3185 r = attach_io_events(bus);
3192 sd_bus_detach_event(bus);
3196 _public_ int sd_bus_detach_event(sd_bus *bus) {
3197 assert_return(bus, -EINVAL);
3202 detach_io_events(bus);
3204 if (bus->time_event_source) {
3205 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3206 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3209 if (bus->quit_event_source) {
3210 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3211 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3214 bus->event = sd_event_unref(bus->event);
3218 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3219 assert_return(bus, NULL);
3224 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3225 assert_return(bus, NULL);
3227 return bus->current_message;
3230 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3231 assert_return(bus, NULL);
3233 return bus->current_slot;
3236 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3237 assert_return(bus, NULL);
3239 return bus->current_handler;
3242 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3243 assert_return(bus, NULL);
3245 return bus->current_userdata;
3248 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3253 assert(default_bus);
3256 return !!*default_bus;
3259 *ret = sd_bus_ref(*default_bus);
3267 b->default_bus_ptr = default_bus;
3275 _public_ int sd_bus_default_system(sd_bus **ret) {
3276 static thread_local sd_bus *default_system_bus = NULL;
3278 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3281 _public_ int sd_bus_default_user(sd_bus **ret) {
3282 static thread_local sd_bus *default_user_bus = NULL;
3284 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3287 _public_ int sd_bus_default(sd_bus **ret) {
3291 /* Let's try our best to reuse another cached connection. If
3292 * the starter bus type is set, connect via our normal
3293 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3294 * we can share the connection with the user/system default
3297 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3299 if (streq(e, "system"))
3300 return sd_bus_default_system(ret);
3301 else if (STR_IN_SET(e, "user", "session"))
3302 return sd_bus_default_user(ret);
3305 /* No type is specified, so we have not other option than to
3306 * use the starter address if it is set. */
3308 e = secure_getenv("DBUS_STARTER_ADDRESS");
3310 static thread_local sd_bus *default_starter_bus = NULL;
3312 return bus_default(sd_bus_open, &default_starter_bus, ret);
3315 /* Finally, if nothing is set use the cached connection for
3316 * the right scope */
3318 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3319 return sd_bus_default_user(ret);
3321 return sd_bus_default_system(ret);
3324 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3325 assert_return(b, -EINVAL);
3326 assert_return(tid, -EINVAL);
3327 assert_return(!bus_pid_changed(b), -ECHILD);
3335 return sd_event_get_tid(b->event, tid);
3340 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3341 _cleanup_free_ char *e = NULL;
3344 assert_return(object_path_is_valid(prefix), -EINVAL);
3345 assert_return(external_id, -EINVAL);
3346 assert_return(ret_path, -EINVAL);
3348 e = bus_label_escape(external_id);
3352 ret = strjoin(prefix, "/", e, NULL);
3360 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3364 assert_return(object_path_is_valid(path), -EINVAL);
3365 assert_return(object_path_is_valid(prefix), -EINVAL);
3366 assert_return(external_id, -EINVAL);
3368 e = object_path_startswith(path, prefix);
3370 *external_id = NULL;
3374 ret = bus_label_unescape(e);
3382 _public_ int sd_bus_try_close(sd_bus *bus) {
3385 assert_return(bus, -EINVAL);
3386 assert_return(!bus_pid_changed(bus), -ECHILD);
3388 if (!bus->is_kernel)
3391 if (!BUS_IS_OPEN(bus->state))
3394 if (bus->rqueue_size > 0)
3397 if (bus->wqueue_size > 0)
3400 r = bus_kernel_try_close(bus);
3408 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3409 assert_return(bus, -EINVAL);
3410 assert_return(description, -EINVAL);
3411 assert_return(bus->description, -ENXIO);
3412 assert_return(!bus_pid_changed(bus), -ECHILD);
3414 *description = bus->description;
3418 int bus_get_root_path(sd_bus *bus) {
3421 if (bus->cgroup_root)
3424 r = cg_get_root_path(&bus->cgroup_root);
3426 bus->cgroup_root = strdup("/");
3427 if (!bus->cgroup_root)
3436 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3439 assert_return(bus, -EINVAL);
3440 assert_return(scope, -EINVAL);
3441 assert_return(!bus_pid_changed(bus), -ECHILD);
3443 if (bus->is_kernel) {
3444 _cleanup_free_ char *n = NULL;
3447 r = bus_kernel_get_bus_name(bus, &n);
3451 if (streq(n, "0-system")) {
3456 dash = strchr(n, '-');
3457 if (streq_ptr(dash, "-user")) {
3468 if (bus->is_system) {
3476 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3478 assert_return(bus, -EINVAL);
3479 assert_return(address, -EINVAL);
3480 assert_return(!bus_pid_changed(bus), -ECHILD);
3483 *address = bus->address;
3490 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3491 assert_return(bus, -EINVAL);
3492 assert_return(mask, -EINVAL);
3493 assert_return(!bus_pid_changed(bus), -ECHILD);
3495 *mask = bus->creds_mask;
3499 int sd_bus_is_bus_client(sd_bus *bus) {
3500 assert_return(bus, -EINVAL);
3501 assert_return(!bus_pid_changed(bus), -ECHILD);
3503 return bus->bus_client;
3506 int sd_bus_is_server(sd_bus *bus) {
3507 assert_return(bus, -EINVAL);
3508 assert_return(!bus_pid_changed(bus), -ECHILD);
3510 return bus->is_server;
3513 int sd_bus_is_anonymous(sd_bus *bus) {
3514 assert_return(bus, -EINVAL);
3515 assert_return(!bus_pid_changed(bus), -ECHILD);
3517 return bus->anonymous_auth;
3520 int sd_bus_is_trusted(sd_bus *bus) {
3521 assert_return(bus, -EINVAL);
3522 assert_return(!bus_pid_changed(bus), -ECHILD);
3524 return bus->trusted;
3527 int sd_bus_is_monitor(sd_bus *bus) {
3528 assert_return(bus, -EINVAL);
3529 assert_return(!bus_pid_changed(bus), -ECHILD);
3531 return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);