1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
38 #include "cgroup-util.h"
39 #include "bus-label.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
55 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
56 static int attach_io_events(sd_bus *b);
57 static void detach_io_events(sd_bus *b);
59 static void bus_close_fds(sd_bus *b) {
65 close_nointr_nofail(b->input_fd);
67 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
68 close_nointr_nofail(b->output_fd);
70 b->input_fd = b->output_fd = -1;
73 static void bus_node_destroy(sd_bus *b, struct node *n) {
74 struct node_callback *c;
75 struct node_vtable *v;
76 struct node_enumerator *e;
84 bus_node_destroy(b, n->child);
86 while ((c = n->callbacks)) {
87 LIST_REMOVE(callbacks, n->callbacks, c);
91 while ((v = n->vtables)) {
92 LIST_REMOVE(vtables, n->vtables, v);
97 while ((e = n->enumerators)) {
98 LIST_REMOVE(enumerators, n->enumerators, e);
103 LIST_REMOVE(siblings, n->parent->child, n);
105 assert_se(hashmap_remove(b->nodes, n->path) == n);
110 static void bus_reset_queues(sd_bus *b) {
113 while (b->rqueue_size > 0)
114 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
118 b->rqueue_allocated = 0;
120 while (b->wqueue_size > 0)
121 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
125 b->wqueue_allocated = 0;
128 static void bus_free(sd_bus *b) {
129 struct filter_callback *f;
134 sd_bus_detach_event(b);
136 if (b->default_bus_ptr)
137 *b->default_bus_ptr = NULL;
142 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
145 free(b->unique_name);
146 free(b->auth_buffer);
151 free(b->cgroup_root);
152 free(b->connection_name);
155 strv_free(b->exec_argv);
157 close_many(b->fds, b->n_fds);
162 hashmap_free_free(b->reply_callbacks);
163 prioq_free(b->reply_callbacks_prioq);
165 while ((f = b->filter_callbacks)) {
166 LIST_REMOVE(callbacks, b->filter_callbacks, f);
170 bus_match_free(&b->match_callbacks);
172 hashmap_free_free(b->vtable_methods);
173 hashmap_free_free(b->vtable_properties);
175 while ((n = hashmap_first(b->nodes)))
176 bus_node_destroy(b, n);
178 hashmap_free(b->nodes);
180 bus_kernel_flush_memfd(b);
182 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
187 _public_ int sd_bus_new(sd_bus **ret) {
190 assert_return(ret, -EINVAL);
196 r->n_ref = REFCNT_INIT;
197 r->input_fd = r->output_fd = -1;
198 r->message_version = 1;
199 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
200 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
201 r->attach_flags |= KDBUS_ATTACH_NAMES;
202 r->original_pid = getpid();
204 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
206 /* We guarantee that wqueue always has space for at least one
208 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
217 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
220 assert_return(bus, -EINVAL);
221 assert_return(bus->state == BUS_UNSET, -EPERM);
222 assert_return(address, -EINVAL);
223 assert_return(!bus_pid_changed(bus), -ECHILD);
235 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
236 assert_return(bus, -EINVAL);
237 assert_return(bus->state == BUS_UNSET, -EPERM);
238 assert_return(input_fd >= 0, -EINVAL);
239 assert_return(output_fd >= 0, -EINVAL);
240 assert_return(!bus_pid_changed(bus), -ECHILD);
242 bus->input_fd = input_fd;
243 bus->output_fd = output_fd;
247 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
250 assert_return(bus, -EINVAL);
251 assert_return(bus->state == BUS_UNSET, -EPERM);
252 assert_return(path, -EINVAL);
253 assert_return(!strv_isempty(argv), -EINVAL);
254 assert_return(!bus_pid_changed(bus), -ECHILD);
266 free(bus->exec_path);
267 strv_free(bus->exec_argv);
275 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
276 assert_return(bus, -EINVAL);
277 assert_return(bus->state == BUS_UNSET, -EPERM);
278 assert_return(!bus_pid_changed(bus), -ECHILD);
280 bus->bus_client = !!b;
284 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
285 assert_return(bus, -EINVAL);
286 assert_return(bus->state == BUS_UNSET, -EPERM);
287 assert_return(!bus_pid_changed(bus), -ECHILD);
289 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
293 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
294 assert_return(bus, -EINVAL);
295 assert_return(bus->state == BUS_UNSET, -EPERM);
296 assert_return(!bus_pid_changed(bus), -ECHILD);
298 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
302 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
303 assert_return(bus, -EINVAL);
304 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
305 assert_return(bus->state == BUS_UNSET, -EPERM);
306 assert_return(!bus_pid_changed(bus), -ECHILD);
308 /* The well knowns we need unconditionally, so that matches can work */
309 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
311 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
314 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
315 assert_return(bus, -EINVAL);
316 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
317 assert_return(bus->state == BUS_UNSET, -EPERM);
318 assert_return(!bus_pid_changed(bus), -ECHILD);
320 bus->is_server = !!b;
321 bus->server_id = server_id;
325 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
326 assert_return(bus, -EINVAL);
327 assert_return(bus->state == BUS_UNSET, -EPERM);
328 assert_return(!bus_pid_changed(bus), -ECHILD);
330 bus->anonymous_auth = !!b;
334 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
335 assert_return(bus, -EINVAL);
336 assert_return(bus->state == BUS_UNSET, -EPERM);
337 assert_return(!bus_pid_changed(bus), -ECHILD);
343 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
346 assert_return(bus, -EINVAL);
347 assert_return(name, -EINVAL);
348 assert_return(bus->state == BUS_UNSET, -EPERM);
349 assert_return(!bus_pid_changed(bus), -ECHILD);
355 free(bus->connection_name);
356 bus->connection_name = n;
361 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
366 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
369 r = sd_bus_message_get_errno(reply);
375 r = sd_bus_message_read(reply, "s", &s);
379 if (!service_name_is_valid(s) || s[0] != ':')
382 bus->unique_name = strdup(s);
383 if (!bus->unique_name)
386 if (bus->state == BUS_HELLO)
387 bus->state = BUS_RUNNING;
392 static int bus_send_hello(sd_bus *bus) {
393 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
398 if (!bus->bus_client || bus->is_kernel)
401 r = sd_bus_message_new_method_call(
404 "org.freedesktop.DBus",
405 "/org/freedesktop/DBus",
406 "org.freedesktop.DBus",
411 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
414 int bus_start_running(sd_bus *bus) {
417 if (bus->bus_client && !bus->is_kernel) {
418 bus->state = BUS_HELLO;
422 bus->state = BUS_RUNNING;
426 static int parse_address_key(const char **p, const char *key, char **value) {
427 size_t l, n = 0, allocated = 0;
437 if (strncmp(*p, key, l) != 0)
450 while (*a != ';' && *a != ',' && *a != 0) {
468 c = (char) ((x << 4) | y);
475 if (!GREEDY_REALLOC(r, allocated, n + 2))
499 static void skip_address_key(const char **p) {
503 *p += strcspn(*p, ",");
509 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
510 _cleanup_free_ char *path = NULL, *abstract = NULL;
519 while (**p != 0 && **p != ';') {
520 r = parse_address_key(p, "guid", guid);
526 r = parse_address_key(p, "path", &path);
532 r = parse_address_key(p, "abstract", &abstract);
541 if (!path && !abstract)
544 if (path && abstract)
549 if (l > sizeof(b->sockaddr.un.sun_path))
552 b->sockaddr.un.sun_family = AF_UNIX;
553 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
554 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
555 } else if (abstract) {
556 l = strlen(abstract);
557 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
560 b->sockaddr.un.sun_family = AF_UNIX;
561 b->sockaddr.un.sun_path[0] = 0;
562 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
563 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
569 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
570 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
572 struct addrinfo *result, hints = {
573 .ai_socktype = SOCK_STREAM,
574 .ai_flags = AI_ADDRCONFIG,
582 while (**p != 0 && **p != ';') {
583 r = parse_address_key(p, "guid", guid);
589 r = parse_address_key(p, "host", &host);
595 r = parse_address_key(p, "port", &port);
601 r = parse_address_key(p, "family", &family);
614 if (streq(family, "ipv4"))
615 hints.ai_family = AF_INET;
616 else if (streq(family, "ipv6"))
617 hints.ai_family = AF_INET6;
622 r = getaddrinfo(host, port, &hints, &result);
626 return -EADDRNOTAVAIL;
628 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
629 b->sockaddr_size = result->ai_addrlen;
631 freeaddrinfo(result);
636 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
638 unsigned n_argv = 0, j;
640 size_t allocated = 0;
648 while (**p != 0 && **p != ';') {
649 r = parse_address_key(p, "guid", guid);
655 r = parse_address_key(p, "path", &path);
661 if (startswith(*p, "argv")) {
665 ul = strtoul(*p + 4, (char**) p, 10);
666 if (errno > 0 || **p != '=' || ul > 256) {
674 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
682 r = parse_address_key(p, NULL, argv + ul);
697 /* Make sure there are no holes in the array, with the
698 * exception of argv[0] */
699 for (j = 1; j < n_argv; j++)
705 if (argv && argv[0] == NULL) {
706 argv[0] = strdup(path);
718 for (j = 0; j < n_argv; j++)
726 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
727 _cleanup_free_ char *path = NULL;
735 while (**p != 0 && **p != ';') {
736 r = parse_address_key(p, "guid", guid);
742 r = parse_address_key(p, "path", &path);
761 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
762 _cleanup_free_ char *machine = NULL;
770 while (**p != 0 && **p != ';') {
771 r = parse_address_key(p, "guid", guid);
777 r = parse_address_key(p, "machine", &machine);
789 if (!filename_is_safe(machine))
793 b->machine = machine;
796 b->sockaddr.un.sun_family = AF_UNIX;
797 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
798 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
803 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
804 _cleanup_free_ char *machine = NULL;
812 while (**p != 0 && **p != ';') {
813 r = parse_address_key(p, "guid", guid);
819 r = parse_address_key(p, "machine", &machine);
831 if (!filename_is_safe(machine))
835 b->machine = machine;
839 b->kernel = strdup("/dev/kdbus/0-system/bus");
846 static void bus_reset_parsed_address(sd_bus *b) {
850 b->sockaddr_size = 0;
851 strv_free(b->exec_argv);
855 b->server_id = SD_ID128_NULL;
862 static int bus_parse_next_address(sd_bus *b) {
863 _cleanup_free_ char *guid = NULL;
871 if (b->address[b->address_index] == 0)
874 bus_reset_parsed_address(b);
876 a = b->address + b->address_index;
885 if (startswith(a, "unix:")) {
888 r = parse_unix_address(b, &a, &guid);
893 } else if (startswith(a, "tcp:")) {
896 r = parse_tcp_address(b, &a, &guid);
902 } else if (startswith(a, "unixexec:")) {
905 r = parse_exec_address(b, &a, &guid);
911 } else if (startswith(a, "kernel:")) {
914 r = parse_kernel_address(b, &a, &guid);
919 } else if (startswith(a, "x-container-unix:")) {
922 r = parse_container_unix_address(b, &a, &guid);
927 } else if (startswith(a, "x-container-kernel:")) {
930 r = parse_container_kernel_address(b, &a, &guid);
943 r = sd_id128_from_string(guid, &b->server_id);
948 b->address_index = a - b->address;
952 static int bus_start_address(sd_bus *b) {
958 bool skipped = false;
963 r = bus_socket_exec(b);
964 else if (b->machine && b->kernel)
965 r = bus_container_connect_kernel(b);
966 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
967 r = bus_container_connect_socket(b);
969 r = bus_kernel_connect(b);
970 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
971 r = bus_socket_connect(b);
977 r = attach_io_events(b);
982 b->last_connect_error = -r;
985 r = bus_parse_next_address(b);
989 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
993 int bus_next_address(sd_bus *b) {
996 bus_reset_parsed_address(b);
997 return bus_start_address(b);
1000 static int bus_start_fd(sd_bus *b) {
1005 assert(b->input_fd >= 0);
1006 assert(b->output_fd >= 0);
1008 r = fd_nonblock(b->input_fd, true);
1012 r = fd_cloexec(b->input_fd, true);
1016 if (b->input_fd != b->output_fd) {
1017 r = fd_nonblock(b->output_fd, true);
1021 r = fd_cloexec(b->output_fd, true);
1026 if (fstat(b->input_fd, &st) < 0)
1029 if (S_ISCHR(b->input_fd))
1030 return bus_kernel_take_fd(b);
1032 return bus_socket_take_fd(b);
1035 _public_ int sd_bus_start(sd_bus *bus) {
1038 assert_return(bus, -EINVAL);
1039 assert_return(bus->state == BUS_UNSET, -EPERM);
1040 assert_return(!bus_pid_changed(bus), -ECHILD);
1042 bus->state = BUS_OPENING;
1044 if (bus->is_server && bus->bus_client)
1047 if (bus->input_fd >= 0)
1048 r = bus_start_fd(bus);
1049 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1050 r = bus_start_address(bus);
1057 return bus_send_hello(bus);
1060 _public_ int sd_bus_open(sd_bus **ret) {
1065 assert_return(ret, -EINVAL);
1067 /* Let's connect to the starter bus if it is set, and
1068 * otherwise to the bus that is appropropriate for the scope
1069 * we are running in */
1071 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1073 if (streq(e, "system"))
1074 return sd_bus_open_system(ret);
1075 else if (streq(e, "session") || streq(e, "user"))
1076 return sd_bus_open_user(ret);
1079 e = secure_getenv("DBUS_STARTER_ADDRESS");
1081 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1082 return sd_bus_open_user(ret);
1084 return sd_bus_open_system(ret);
1091 r = sd_bus_set_address(b, e);
1095 b->bus_client = true;
1097 /* We don't know whether the bus is trusted or not, so better
1098 * be safe, and authenticate everything */
1100 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1102 r = sd_bus_start(b);
1114 _public_ int sd_bus_open_system(sd_bus **ret) {
1119 assert_return(ret, -EINVAL);
1125 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1127 r = sd_bus_set_address(b, e);
1129 r = sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1133 b->bus_client = true;
1134 b->is_system = true;
1136 /* Let's do per-method access control on the system bus. We
1137 * need the caller's UID and capability set for that. */
1139 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1141 r = sd_bus_start(b);
1153 _public_ int sd_bus_open_user(sd_bus **ret) {
1158 assert_return(ret, -EINVAL);
1164 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1166 r = sd_bus_set_address(b, e);
1170 e = secure_getenv("XDG_RUNTIME_DIR");
1172 _cleanup_free_ char *ee = NULL;
1174 ee = bus_address_escape(e);
1181 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1183 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1187 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1189 return -ECONNREFUSED;
1199 b->bus_client = true;
1202 /* We don't do any per-method access control on the user
1206 r = sd_bus_start(b);
1218 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1219 _cleanup_free_ char *e = NULL;
1224 assert_return(host, -EINVAL);
1225 assert_return(ret, -EINVAL);
1227 e = bus_address_escape(host);
1231 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1235 r = sd_bus_new(&bus);
1242 bus->bus_client = true;
1244 r = sd_bus_start(bus);
1254 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1255 _cleanup_free_ char *e = NULL;
1260 assert_return(machine, -EINVAL);
1261 assert_return(ret, -EINVAL);
1262 assert_return(filename_is_safe(machine), -EINVAL);
1264 e = bus_address_escape(machine);
1269 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1271 p = strjoin("x-container-unix:machine=", e, NULL);
1276 r = sd_bus_new(&bus);
1283 bus->bus_client = true;
1285 r = sd_bus_start(bus);
1295 _public_ void sd_bus_close(sd_bus *bus) {
1299 if (bus->state == BUS_CLOSED)
1301 if (bus_pid_changed(bus))
1304 bus->state = BUS_CLOSED;
1306 sd_bus_detach_event(bus);
1308 /* Drop all queued messages so that they drop references to
1309 * the bus object and the bus may be freed */
1310 bus_reset_queues(bus);
1312 if (!bus->is_kernel)
1315 /* We'll leave the fd open in case this is a kernel bus, since
1316 * there might still be memblocks around that reference this
1317 * bus, and they might need to invoke the KDBUS_CMD_FREE
1318 * ioctl on the fd when they are freed. */
1321 static void bus_enter_closing(sd_bus *bus) {
1324 if (bus->state != BUS_OPENING &&
1325 bus->state != BUS_AUTHENTICATING &&
1326 bus->state != BUS_HELLO &&
1327 bus->state != BUS_RUNNING)
1330 bus->state = BUS_CLOSING;
1333 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1334 assert_return(bus, NULL);
1336 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1341 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1347 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1350 for (i = 0; i < bus->rqueue_size; i++)
1351 if (bus->rqueue[i]->n_ref > 1) {
1357 for (i = 0; i < bus->wqueue_size; i++)
1358 if (bus->wqueue[i]->n_ref > 1) {
1364 /* We are the only holders on the messages, and the
1365 * messages are the only holders on us, so let's drop
1366 * the messages and thus implicitly also kill our own
1367 * last references */
1370 bus_reset_queues(bus);
1373 i = REFCNT_DEC(bus->n_ref);
1381 _public_ int sd_bus_is_open(sd_bus *bus) {
1383 assert_return(bus, -EINVAL);
1384 assert_return(!bus_pid_changed(bus), -ECHILD);
1386 return BUS_IS_OPEN(bus->state);
1389 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1392 assert_return(bus, -EINVAL);
1393 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1394 assert_return(!bus_pid_changed(bus), -ECHILD);
1396 if (type == SD_BUS_TYPE_UNIX_FD) {
1397 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1400 r = bus_ensure_running(bus);
1404 return bus->can_fds;
1407 return bus_type_is_valid(type);
1410 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1413 assert_return(bus, -EINVAL);
1414 assert_return(server_id, -EINVAL);
1415 assert_return(!bus_pid_changed(bus), -ECHILD);
1417 r = bus_ensure_running(bus);
1421 *server_id = bus->server_id;
1425 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1430 /* If we copy the same message to multiple
1431 * destinations, avoid using the same cookie
1433 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1438 timeout = BUS_DEFAULT_TIMEOUT;
1440 return bus_message_seal(m, ++b->cookie, timeout);
1443 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1446 /* Do packet version and endianess already match? */
1447 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1448 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1451 /* No? Then remarshal! */
1452 return bus_message_remarshal(b, m);
1455 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1459 /* The bus specification says the serial number cannot be 0,
1460 * hence let's fill something in for synthetic messages. Since
1461 * synthetic messages might have a fake sender and we don't
1462 * want to interfere with the real sender's serial numbers we
1463 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1464 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1465 * even though kdbus can do 64bit. */
1467 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1470 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1477 r = bus_kernel_write_message(bus, m, hint_sync_call);
1479 r = bus_socket_write_message(bus, m, idx);
1484 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1485 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1486 bus_message_type_to_string(m->header->type),
1487 strna(sd_bus_message_get_sender(m)),
1488 strna(sd_bus_message_get_destination(m)),
1489 strna(sd_bus_message_get_path(m)),
1490 strna(sd_bus_message_get_interface(m)),
1491 strna(sd_bus_message_get_member(m)),
1492 (unsigned long) BUS_MESSAGE_COOKIE(m),
1493 (unsigned long) m->reply_cookie,
1494 strna(m->error.message));
1499 static int dispatch_wqueue(sd_bus *bus) {
1503 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1505 while (bus->wqueue_size > 0) {
1507 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1511 /* Didn't do anything this time */
1513 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1514 /* Fully written. Let's drop the entry from
1517 * This isn't particularly optimized, but
1518 * well, this is supposed to be our worst-case
1519 * buffer only, and the socket buffer is
1520 * supposed to be our primary buffer, and if
1521 * it got full, then all bets are off
1524 bus->wqueue_size --;
1525 sd_bus_message_unref(bus->wqueue[0]);
1526 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1536 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1540 return bus_kernel_read_message(bus, hint_priority, priority);
1542 return bus_socket_read_message(bus);
1545 int bus_rqueue_make_room(sd_bus *bus) {
1548 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1551 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1557 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1562 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1564 /* Note that the priority logic is only available on kdbus,
1565 * where the rqueue is unused. We check the rqueue here
1566 * anyway, because it's simple... */
1569 if (bus->rqueue_size > 0) {
1570 /* Dispatch a queued message */
1572 *m = bus->rqueue[0];
1573 bus->rqueue_size --;
1574 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1578 /* Try to read a new message */
1579 r = bus_read_message(bus, hint_priority, priority);
1589 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1590 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1593 assert_return(bus, -EINVAL);
1594 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1595 assert_return(m, -EINVAL);
1596 assert_return(!bus_pid_changed(bus), -ECHILD);
1599 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1606 /* If the cookie number isn't kept, then we know that no reply
1608 if (!cookie && !m->sealed)
1609 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1611 r = bus_seal_message(bus, m, 0);
1615 /* Remarshall if we have to. This will possibly unref the
1616 * message and place a replacement in m */
1617 r = bus_remarshal_message(bus, &m);
1621 /* If this is a reply and no reply was requested, then let's
1622 * suppress this, if we can */
1623 if (m->dont_send && !cookie)
1626 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1629 r = bus_write_message(bus, m, hint_sync_call, &idx);
1631 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1632 bus_enter_closing(bus);
1637 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1638 /* Wasn't fully written. So let's remember how
1639 * much was written. Note that the first entry
1640 * of the wqueue array is always allocated so
1641 * that we always can remember how much was
1643 bus->wqueue[0] = sd_bus_message_ref(m);
1644 bus->wqueue_size = 1;
1648 /* Just append it to the queue. */
1650 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1653 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1656 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1660 *cookie = BUS_MESSAGE_COOKIE(m);
1665 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1666 return bus_send_internal(bus, m, cookie, false);
1669 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1672 assert_return(bus, -EINVAL);
1673 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1674 assert_return(m, -EINVAL);
1675 assert_return(!bus_pid_changed(bus), -ECHILD);
1677 if (!streq_ptr(m->destination, destination)) {
1682 r = sd_bus_message_set_destination(m, destination);
1687 return sd_bus_send(bus, m, cookie);
1690 static usec_t calc_elapse(uint64_t usec) {
1691 if (usec == (uint64_t) -1)
1694 return now(CLOCK_MONOTONIC) + usec;
1697 static int timeout_compare(const void *a, const void *b) {
1698 const struct reply_callback *x = a, *y = b;
1700 if (x->timeout != 0 && y->timeout == 0)
1703 if (x->timeout == 0 && y->timeout != 0)
1706 if (x->timeout < y->timeout)
1709 if (x->timeout > y->timeout)
1715 _public_ int sd_bus_call_async(
1718 sd_bus_message_handler_t callback,
1723 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1724 struct reply_callback *c;
1727 assert_return(bus, -EINVAL);
1728 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1729 assert_return(m, -EINVAL);
1730 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1731 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1732 assert_return(callback, -EINVAL);
1733 assert_return(!bus_pid_changed(bus), -ECHILD);
1735 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1739 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1743 r = bus_seal_message(bus, m, usec);
1747 r = bus_remarshal_message(bus, &m);
1751 c = new0(struct reply_callback, 1);
1755 c->callback = callback;
1756 c->userdata = userdata;
1757 c->cookie = BUS_MESSAGE_COOKIE(m);
1758 c->timeout = calc_elapse(m->timeout);
1760 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1766 if (c->timeout != 0) {
1767 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1770 sd_bus_call_async_cancel(bus, c->cookie);
1775 r = sd_bus_send(bus, m, cookie);
1777 sd_bus_call_async_cancel(bus, c->cookie);
1784 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1785 struct reply_callback *c;
1787 assert_return(bus, -EINVAL);
1788 assert_return(cookie != 0, -EINVAL);
1789 assert_return(!bus_pid_changed(bus), -ECHILD);
1791 c = hashmap_remove(bus->reply_callbacks, &cookie);
1795 if (c->timeout != 0)
1796 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1802 int bus_ensure_running(sd_bus *bus) {
1807 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1809 if (bus->state == BUS_RUNNING)
1813 r = sd_bus_process(bus, NULL);
1816 if (bus->state == BUS_RUNNING)
1821 r = sd_bus_wait(bus, (uint64_t) -1);
1827 _public_ int sd_bus_call(
1831 sd_bus_error *error,
1832 sd_bus_message **reply) {
1834 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1840 assert_return(bus, -EINVAL);
1841 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1842 assert_return(m, -EINVAL);
1843 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1844 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1845 assert_return(!bus_error_is_dirty(error), -EINVAL);
1846 assert_return(!bus_pid_changed(bus), -ECHILD);
1848 r = bus_ensure_running(bus);
1852 i = bus->rqueue_size;
1854 r = bus_seal_message(bus, m, usec);
1858 r = bus_remarshal_message(bus, &m);
1862 r = bus_send_internal(bus, m, &cookie, true);
1866 timeout = calc_elapse(m->timeout);
1871 while (i < bus->rqueue_size) {
1872 sd_bus_message *incoming = NULL;
1874 incoming = bus->rqueue[i];
1876 if (incoming->reply_cookie == cookie) {
1877 /* Found a match! */
1879 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1882 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1887 sd_bus_message_unref(incoming);
1890 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1891 r = sd_bus_error_copy(error, &incoming->error);
1895 sd_bus_message_unref(incoming);
1898 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1901 streq(bus->unique_name, incoming->sender)) {
1903 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1906 /* Our own message? Somebody is trying
1907 * to send its own client a message,
1908 * let's not dead-lock, let's fail
1911 sd_bus_message_unref(incoming);
1915 /* Try to read more, right-away */
1919 r = bus_read_message(bus, false, 0);
1921 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1922 bus_enter_closing(bus);
1934 n = now(CLOCK_MONOTONIC);
1940 left = (uint64_t) -1;
1942 r = bus_poll(bus, true, left);
1948 r = dispatch_wqueue(bus);
1950 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1951 bus_enter_closing(bus);
1960 _public_ int sd_bus_get_fd(sd_bus *bus) {
1962 assert_return(bus, -EINVAL);
1963 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1964 assert_return(!bus_pid_changed(bus), -ECHILD);
1966 return bus->input_fd;
1969 _public_ int sd_bus_get_events(sd_bus *bus) {
1972 assert_return(bus, -EINVAL);
1973 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1974 assert_return(!bus_pid_changed(bus), -ECHILD);
1976 if (bus->state == BUS_OPENING)
1978 else if (bus->state == BUS_AUTHENTICATING) {
1980 if (bus_socket_auth_needs_write(bus))
1985 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1986 if (bus->rqueue_size <= 0)
1988 if (bus->wqueue_size > 0)
1995 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1996 struct reply_callback *c;
1998 assert_return(bus, -EINVAL);
1999 assert_return(timeout_usec, -EINVAL);
2000 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
2001 assert_return(!bus_pid_changed(bus), -ECHILD);
2003 if (bus->state == BUS_CLOSING) {
2008 if (bus->state == BUS_AUTHENTICATING) {
2009 *timeout_usec = bus->auth_timeout;
2013 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2014 *timeout_usec = (uint64_t) -1;
2018 if (bus->rqueue_size > 0) {
2023 c = prioq_peek(bus->reply_callbacks_prioq);
2025 *timeout_usec = (uint64_t) -1;
2029 *timeout_usec = c->timeout;
2033 static int process_timeout(sd_bus *bus) {
2034 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2035 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2036 struct reply_callback *c;
2042 c = prioq_peek(bus->reply_callbacks_prioq);
2046 n = now(CLOCK_MONOTONIC);
2050 r = bus_message_new_synthetic_error(
2053 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2058 m->sender = "org.freedesktop.DBus";
2060 r = bus_seal_synthetic_message(bus, m);
2064 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2065 hashmap_remove(bus->reply_callbacks, &c->cookie);
2068 bus->iteration_counter ++;
2070 r = c->callback(bus, m, c->userdata, &error_buffer);
2071 r = bus_maybe_reply_error(m, r, &error_buffer);
2074 bus->current = NULL;
2079 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2083 if (bus->state != BUS_HELLO)
2086 /* Let's make sure the first message on the bus is the HELLO
2087 * reply. But note that we don't actually parse the message
2088 * here (we leave that to the usual handling), we just verify
2089 * we don't let any earlier msg through. */
2091 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2092 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2095 if (m->reply_cookie != bus->hello_cookie)
2101 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2102 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2103 struct reply_callback *c;
2109 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2110 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2113 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2117 if (c->timeout != 0)
2118 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2120 r = sd_bus_message_rewind(m, true);
2124 r = c->callback(bus, m, c->userdata, &error_buffer);
2125 r = bus_maybe_reply_error(m, r, &error_buffer);
2131 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2132 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2133 struct filter_callback *l;
2140 bus->filter_callbacks_modified = false;
2142 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2144 if (bus->filter_callbacks_modified)
2147 /* Don't run this more than once per iteration */
2148 if (l->last_iteration == bus->iteration_counter)
2151 l->last_iteration = bus->iteration_counter;
2153 r = sd_bus_message_rewind(m, true);
2157 r = l->callback(bus, m, l->userdata, &error_buffer);
2158 r = bus_maybe_reply_error(m, r, &error_buffer);
2164 } while (bus->filter_callbacks_modified);
2169 static int process_match(sd_bus *bus, sd_bus_message *m) {
2176 bus->match_callbacks_modified = false;
2178 r = bus_match_run(bus, &bus->match_callbacks, m);
2182 } while (bus->match_callbacks_modified);
2187 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2188 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2194 if (bus->manual_peer_interface)
2197 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2200 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2203 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2206 if (streq_ptr(m->member, "Ping"))
2207 r = sd_bus_message_new_method_return(m, &reply);
2208 else if (streq_ptr(m->member, "GetMachineId")) {
2212 r = sd_id128_get_machine(&id);
2216 r = sd_bus_message_new_method_return(m, &reply);
2220 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2222 r = sd_bus_message_new_method_errorf(
2224 SD_BUS_ERROR_UNKNOWN_METHOD,
2225 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2231 r = sd_bus_send(bus, reply, NULL);
2238 static int process_message(sd_bus *bus, sd_bus_message *m) {
2245 bus->iteration_counter++;
2247 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2248 bus_message_type_to_string(m->header->type),
2249 strna(sd_bus_message_get_sender(m)),
2250 strna(sd_bus_message_get_destination(m)),
2251 strna(sd_bus_message_get_path(m)),
2252 strna(sd_bus_message_get_interface(m)),
2253 strna(sd_bus_message_get_member(m)),
2254 (unsigned long) BUS_MESSAGE_COOKIE(m),
2255 (unsigned long) m->reply_cookie,
2256 strna(m->error.message));
2258 r = process_hello(bus, m);
2262 r = process_reply(bus, m);
2266 r = process_filter(bus, m);
2270 r = process_match(bus, m);
2274 r = process_builtin(bus, m);
2278 r = bus_process_object(bus, m);
2281 bus->current = NULL;
2285 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2286 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2290 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2292 r = process_timeout(bus);
2296 r = dispatch_wqueue(bus);
2300 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2306 r = process_message(bus, m);
2311 r = sd_bus_message_rewind(m, true);
2320 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2322 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2323 strna(sd_bus_message_get_sender(m)),
2324 strna(sd_bus_message_get_path(m)),
2325 strna(sd_bus_message_get_interface(m)),
2326 strna(sd_bus_message_get_member(m)));
2328 r = sd_bus_reply_method_errorf(
2330 SD_BUS_ERROR_UNKNOWN_OBJECT,
2331 "Unknown object '%s'.", m->path);
2345 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2346 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2347 struct reply_callback *c;
2351 assert(bus->state == BUS_CLOSING);
2353 c = hashmap_first(bus->reply_callbacks);
2355 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2357 /* First, fail all outstanding method calls */
2358 r = bus_message_new_synthetic_error(
2361 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2366 r = bus_seal_synthetic_message(bus, m);
2370 if (c->timeout != 0)
2371 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2373 hashmap_remove(bus->reply_callbacks, &c->cookie);
2376 bus->iteration_counter++;
2378 r = c->callback(bus, m, c->userdata, &error_buffer);
2379 r = bus_maybe_reply_error(m, r, &error_buffer);
2385 /* Then, synthesize a Disconnected message */
2386 r = sd_bus_message_new_signal(
2389 "/org/freedesktop/DBus/Local",
2390 "org.freedesktop.DBus.Local",
2395 m->sender = "org.freedesktop.DBus.Local";
2397 r = bus_seal_synthetic_message(bus, m);
2404 bus->iteration_counter++;
2406 r = process_filter(bus, m);
2410 r = process_match(bus, m);
2422 bus->current = NULL;
2426 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2427 BUS_DONT_DESTROY(bus);
2430 /* Returns 0 when we didn't do anything. This should cause the
2431 * caller to invoke sd_bus_wait() before returning the next
2432 * time. Returns > 0 when we did something, which possibly
2433 * means *ret is filled in with an unprocessed message. */
2435 assert_return(bus, -EINVAL);
2436 assert_return(!bus_pid_changed(bus), -ECHILD);
2438 /* We don't allow recursively invoking sd_bus_process(). */
2439 assert_return(!bus->current, -EBUSY);
2441 switch (bus->state) {
2450 r = bus_socket_process_opening(bus);
2451 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2452 bus_enter_closing(bus);
2460 case BUS_AUTHENTICATING:
2461 r = bus_socket_process_authenticating(bus);
2462 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2463 bus_enter_closing(bus);
2475 r = process_running(bus, hint_priority, priority, ret);
2476 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2477 bus_enter_closing(bus);
2487 return process_closing(bus, ret);
2490 assert_not_reached("Unknown state");
2493 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2494 return bus_process_internal(bus, false, 0, ret);
2497 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2498 return bus_process_internal(bus, true, priority, ret);
2501 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2502 struct pollfd p[2] = {};
2505 usec_t m = (usec_t) -1;
2509 if (bus->state == BUS_CLOSING)
2512 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2514 e = sd_bus_get_events(bus);
2519 /* The caller really needs some more data, he doesn't
2520 * care about what's already read, or any timeouts
2525 /* The caller wants to process if there's something to
2526 * process, but doesn't care otherwise */
2528 r = sd_bus_get_timeout(bus, &until);
2533 nw = now(CLOCK_MONOTONIC);
2534 m = until > nw ? until - nw : 0;
2538 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2541 p[0].fd = bus->input_fd;
2542 if (bus->output_fd == bus->input_fd) {
2546 p[0].events = e & POLLIN;
2547 p[1].fd = bus->output_fd;
2548 p[1].events = e & POLLOUT;
2552 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2556 return r > 0 ? 1 : 0;
2559 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2561 assert_return(bus, -EINVAL);
2562 assert_return(!bus_pid_changed(bus), -ECHILD);
2564 if (bus->state == BUS_CLOSING)
2567 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2569 if (bus->rqueue_size > 0)
2572 return bus_poll(bus, false, timeout_usec);
2575 _public_ int sd_bus_flush(sd_bus *bus) {
2578 assert_return(bus, -EINVAL);
2579 assert_return(!bus_pid_changed(bus), -ECHILD);
2581 if (bus->state == BUS_CLOSING)
2584 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2586 r = bus_ensure_running(bus);
2590 if (bus->wqueue_size <= 0)
2594 r = dispatch_wqueue(bus);
2596 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2597 bus_enter_closing(bus);
2604 if (bus->wqueue_size <= 0)
2607 r = bus_poll(bus, false, (uint64_t) -1);
2613 _public_ int sd_bus_add_filter(sd_bus *bus,
2614 sd_bus_message_handler_t callback,
2617 struct filter_callback *f;
2619 assert_return(bus, -EINVAL);
2620 assert_return(callback, -EINVAL);
2621 assert_return(!bus_pid_changed(bus), -ECHILD);
2623 f = new0(struct filter_callback, 1);
2626 f->callback = callback;
2627 f->userdata = userdata;
2629 bus->filter_callbacks_modified = true;
2630 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2634 _public_ int sd_bus_remove_filter(sd_bus *bus,
2635 sd_bus_message_handler_t callback,
2638 struct filter_callback *f;
2640 assert_return(bus, -EINVAL);
2641 assert_return(callback, -EINVAL);
2642 assert_return(!bus_pid_changed(bus), -ECHILD);
2644 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2645 if (f->callback == callback && f->userdata == userdata) {
2646 bus->filter_callbacks_modified = true;
2647 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2656 _public_ int sd_bus_add_match(sd_bus *bus,
2658 sd_bus_message_handler_t callback,
2661 struct bus_match_component *components = NULL;
2662 unsigned n_components = 0;
2663 uint64_t cookie = 0;
2666 assert_return(bus, -EINVAL);
2667 assert_return(match, -EINVAL);
2668 assert_return(!bus_pid_changed(bus), -ECHILD);
2670 r = bus_match_parse(match, &components, &n_components);
2674 if (bus->bus_client) {
2675 cookie = ++bus->match_cookie;
2677 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2682 bus->match_callbacks_modified = true;
2683 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2685 if (bus->bus_client)
2686 bus_remove_match_internal(bus, match, cookie);
2690 bus_match_parse_free(components, n_components);
2694 _public_ int sd_bus_remove_match(sd_bus *bus,
2696 sd_bus_message_handler_t callback,
2699 struct bus_match_component *components = NULL;
2700 unsigned n_components = 0;
2702 uint64_t cookie = 0;
2704 assert_return(bus, -EINVAL);
2705 assert_return(match, -EINVAL);
2706 assert_return(!bus_pid_changed(bus), -ECHILD);
2708 r = bus_match_parse(match, &components, &n_components);
2712 bus->match_callbacks_modified = true;
2713 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2715 if (bus->bus_client)
2716 q = bus_remove_match_internal(bus, match, cookie);
2718 bus_match_parse_free(components, n_components);
2720 return r < 0 ? r : q;
2723 bool bus_pid_changed(sd_bus *bus) {
2726 /* We don't support people creating a bus connection and
2727 * keeping it around over a fork(). Let's complain. */
2729 return bus->original_pid != getpid();
2732 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2733 sd_bus *bus = userdata;
2738 r = sd_bus_process(bus, NULL);
2745 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2746 sd_bus *bus = userdata;
2751 r = sd_bus_process(bus, NULL);
2758 static int prepare_callback(sd_event_source *s, void *userdata) {
2759 sd_bus *bus = userdata;
2766 e = sd_bus_get_events(bus);
2770 if (bus->output_fd != bus->input_fd) {
2772 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2776 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2780 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2785 r = sd_bus_get_timeout(bus, &until);
2791 j = sd_event_source_set_time(bus->time_event_source, until);
2796 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2803 static int quit_callback(sd_event_source *event, void *userdata) {
2804 sd_bus *bus = userdata;
2813 static int attach_io_events(sd_bus *bus) {
2818 if (bus->input_fd < 0)
2824 if (!bus->input_io_event_source) {
2825 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2829 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2833 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2835 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2840 if (bus->output_fd != bus->input_fd) {
2841 assert(bus->output_fd >= 0);
2843 if (!bus->output_io_event_source) {
2844 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
2848 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2850 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2859 static void detach_io_events(sd_bus *bus) {
2862 if (bus->input_io_event_source) {
2863 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2864 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2867 if (bus->output_io_event_source) {
2868 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2869 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2873 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2876 assert_return(bus, -EINVAL);
2877 assert_return(!bus->event, -EBUSY);
2879 assert(!bus->input_io_event_source);
2880 assert(!bus->output_io_event_source);
2881 assert(!bus->time_event_source);
2884 bus->event = sd_event_ref(event);
2886 r = sd_event_default(&bus->event);
2891 bus->event_priority = priority;
2893 r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus);
2897 r = sd_event_source_set_priority(bus->time_event_source, priority);
2901 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
2905 r = attach_io_events(bus);
2912 sd_bus_detach_event(bus);
2916 _public_ int sd_bus_detach_event(sd_bus *bus) {
2917 assert_return(bus, -EINVAL);
2922 detach_io_events(bus);
2924 if (bus->time_event_source) {
2925 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2926 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2929 if (bus->quit_event_source) {
2930 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2931 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2935 bus->event = sd_event_unref(bus->event);
2940 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2941 assert_return(bus, NULL);
2946 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2947 assert_return(bus, NULL);
2949 return bus->current;
2952 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2957 assert(default_bus);
2960 return !!*default_bus;
2963 *ret = sd_bus_ref(*default_bus);
2971 b->default_bus_ptr = default_bus;
2979 _public_ int sd_bus_default_system(sd_bus **ret) {
2980 static thread_local sd_bus *default_system_bus = NULL;
2982 return bus_default(sd_bus_open_system, &default_system_bus, ret);
2985 _public_ int sd_bus_default_user(sd_bus **ret) {
2986 static thread_local sd_bus *default_user_bus = NULL;
2988 return bus_default(sd_bus_open_user, &default_user_bus, ret);
2991 _public_ int sd_bus_default(sd_bus **ret) {
2995 /* Let's try our best to reuse another cached connection. If
2996 * the starter bus type is set, connect via our normal
2997 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
2998 * we can share the connection with the user/system default
3001 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3003 if (streq(e, "system"))
3004 return sd_bus_default_system(ret);
3005 else if (streq(e, "user") || streq(e, "session"))
3006 return sd_bus_default_user(ret);
3009 /* No type is specified, so we have not other option than to
3010 * use the starter address if it is set. */
3012 e = secure_getenv("DBUS_STARTER_ADDRESS");
3014 static thread_local sd_bus *default_starter_bus = NULL;
3016 return bus_default(sd_bus_open, &default_starter_bus, ret);
3019 /* Finally, if nothing is set use the cached connection for
3020 * the right scope */
3022 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3023 return sd_bus_default_user(ret);
3025 return sd_bus_default_system(ret);
3028 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3029 assert_return(b, -EINVAL);
3030 assert_return(tid, -EINVAL);
3031 assert_return(!bus_pid_changed(b), -ECHILD);
3039 return sd_event_get_tid(b->event, tid);
3044 _public_ char *sd_bus_label_escape(const char *s) {
3045 return bus_label_escape(s);
3048 _public_ char *sd_bus_label_unescape(const char *f) {
3049 return bus_label_unescape(f);
3052 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3057 assert_return(bus, -EINVAL);
3058 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3059 assert_return(ret, -EINVAL);
3060 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3061 assert_return(!bus_pid_changed(bus), -ECHILD);
3062 assert_return(!bus->is_kernel, -ENOTSUP);
3064 if (!bus->ucred_valid && !isempty(bus->label))
3067 c = bus_creds_new();
3071 if (bus->ucred_valid) {
3072 pid = c->pid = bus->ucred.pid;
3073 c->uid = bus->ucred.uid;
3074 c->gid = bus->ucred.gid;
3076 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3079 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3080 c->label = strdup(bus->label);
3082 sd_bus_creds_unref(c);
3086 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3089 r = bus_creds_add_more(c, mask, pid, 0);
3097 _public_ int sd_bus_try_close(sd_bus *bus) {
3100 assert_return(bus, -EINVAL);
3101 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3102 assert_return(!bus_pid_changed(bus), -ECHILD);
3103 assert_return(bus->is_kernel, -ENOTSUP);
3105 if (bus->rqueue_size > 0)
3108 if (bus->wqueue_size > 0)
3111 r = bus_kernel_try_close(bus);
3119 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3120 assert_return(bus, -EINVAL);
3121 assert_return(name, -EINVAL);
3122 assert_return(!bus_pid_changed(bus), -ECHILD);
3124 *name = bus->connection_name;